一个数据库操作类

数据库连接类

         private   string  conStr;
         private  DataType dataType;

         /**/ /// <summary>
        /// 数据库连接字符串
        /// </summary>
         public   string  ConStr
         ... {
            get
            ...{
                return conStr;
            }
            set
            ...{
                conStr = value;
            }
        }

         /**/ /// <summary>
        /// 数据库类型
        /// </summary>
         public  DataType DataType
         ... {
            get
            ...{
                return dataType;
            }
            set
            ...{
                dataType = value;
            }
        }

         /**/ /// <summary>
        /// 数据库连接
        /// </summary>
        /// <param name="conStr">数据库连接字符串</param>
        /// <param name="dataType">数据库类型</param>
         public  DataCons( string  conStr,DataType dataType)
         ... {
            ConStr = conStr;
            DataType = dataType;
        }

         /**/ /// <summary>
        /// 数据库连接(默认 sqlserver)
        /// </summary>
         public  DataCons()
         ... {
            DataType = DataType.SqlServer;
        }
    }

数据连接初始化

     /**/ /// <summary>
    /// 数据连接初始化
    /// </summary>
     public   class  InitDataCon
     ... {
        private static DataCons[] dataConsList;

        /**//// <summary>
        /// 设置数据库连接
        /// </summary>
        /// <param name="dataConList">数据库连接字符串数组</param>
        public static void SetCon(params DataCons[] dataConList)
        ...{
            dataConsList = dataConList;
        }

        /**//// <summary>
        /// 获取数据库连接
        /// </summary>
        /// <param name="conListIndex">索引</param>
        /// <returns></returns>
        public static DataCons GetCon(int conListIndex)
        ...{
            return dataConsList[conListIndex];
        }
    }

数据库连接类型

     /**/ /// <summary>
    /// 数据库连接类型
    /// </summary>
     public   enum  DataType
     ... {
        SqlServer = 1,
        Access = 2,
        Oracle = 3,
        Others = 4,
    }

抽象数据库连接基类

     /**/ /// <summary>
    /// 抽象数据库连接基类
    /// </summary>
     public   abstract   class  AbstractDataControl
     ... {
        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public abstract DataSet GetDataSet(string sqlStr,string dataConStr);

        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="queryType">查询类型</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <param name="queryList">查询类型对应数组</param>
        /// <returns>返回数据集</returns>
        public abstract DataSet GetDataSet(object queryType, string dataConStr, params string[] queryList);

        /**//// <summary>
        /// 返回数据表
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public abstract DataTable GetDataTable(string sqlStr, string dataConStr);

        /**//// <summary>
        /// 返回一行数据
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public abstract DataRow GetDataRow(string sqlStr, string dataConStr);

        /**//// <summary>
        /// 返回DataReader
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public abstract object GetDataReader(string sqlStr, string dataConStr);

        /**//// <summary>
        /// 返回一个值
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public abstract string GetDataFristRC(string sqlStr, string dataConStr);

        /**//// <summary>
        /// 执行无返回值操作
        /// </summary>
        /// <param name="sqlStr">sql语句(多个语句用";"分开)</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        public abstract void ExeNoQuery(string sqlStr, string dataConStr);
    }

Sql数据库操作类

     public   class  SqlDataControl : AbstractDataControl
     ... {
        private string GetQueryStr(SqlQueryType queryType, string name, string[] parameterList)
        ...{
            string returnStr = "";
            string listStr = "";
            foreach (string parameter in parameterList)
            ...{
                listStr = listStr + ","+ parameter ;
            }
            if (!(listStr == ""))
                listStr = listStr.Substring(1);
            switch (queryType)
            ...{
                case SqlQueryType .SqlViewTable:
                    returnStr = "select * from " + name;
                    break;
                case SqlQueryType .SqlFunction :
                    returnStr = "select * from " + name + "(" + listStr + ")";
                    break;
                case SqlQueryType .SqlProcedure :
                    returnStr = "exec " + name + " " + listStr;
                    break;
                default :
                    break;
            }
            return returnStr;
        }

        private string GetQueryStr(SqlQueryType queryType, string name)
        ...{
            string returnStr = "";
            switch (queryType)
            ...{
                case SqlQueryType.SqlViewTable:
                    returnStr = "select * from " + name;
                    break;
                case SqlQueryType.SqlFunction:
                    returnStr = "select * from " + name + "()";
                    break;
                case SqlQueryType.SqlProcedure:
                    returnStr = "exec " + name;
                    break;
                case SqlQueryType .SqlStr :
                    returnStr = name;
                    break;
                default:
                    break;
            }
            return returnStr;
        }

        public override DataSet GetDataSet(string sqlStr, string dataConStr)
        ...{
            DataSet returnDS = new DataSet();
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlDataAdapter sqlDa = new SqlDataAdapter(sqlStr, sqlCon);
            try
            ...{
                sqlDa.Fill(returnDS);
                return returnDS;
            }
            catch (System.Data.SqlClient.SqlException ex)
            ...{
                throw new Exception(ex.ToString());
            }
            finally
            ...{
                sqlCon.Close();
                sqlDa.Dispose();
                returnDS = null;
            }
        }

        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="queryType">查询类型</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <param name="nameList">名字列表</param>
        /// <returns></returns>
        public override DataSet GetDataSet(object queryType, string dataConStr, params string[] nameList)
        ...{
            string queryStr="";
            foreach (string queryName in nameList )
            ...{
                queryStr = queryStr + GetQueryStr((SqlQueryType)queryType, queryName) + ";";
            }
            return GetDataSet(queryStr, dataConStr);
        }

        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="queryType">查询类型</param>
        /// <param name="nameList">名字数组</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <param name="parameterList">输入参数数组</param>
        /// <returns></returns>
        public DataSet GetDataSet(SqlQueryType queryType, string dataConStr, string[] nameList, params string[][] parameterList)
        ...{
            string queryStr = "";
            for (int i = 0; i < nameList.Length;i++ )
            ...{
                queryStr = queryStr + GetQueryStr(queryType, nameList[i],parameterList [i]) + ";";
            }
            return GetDataSet(queryStr, dataConStr);
        }
       
        /**//// <summary>
        /// 返回数据表
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns>返回数据表</returns>
        public override DataTable GetDataTable(string sqlStr, string dataConStr)
        ...{
            DataTable returnDt = new DataTable();
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlDataAdapter sqlDa = new SqlDataAdapter(sqlStr, sqlCon);
            try
            ...{
                sqlDa.Fill(returnDt);
                return returnDt;
            }
            catch (System.Data.SqlClient.SqlException ex)
            ...{
                throw new Exception(ex.ToString());
            }
            finally
            ...{
                sqlCon.Close();
                sqlDa.Dispose();
                returnDt = null;
            }
        }

        /**//// <summary>
        /// 返回数据表
        /// </summary>
        /// <param name="queryType">查询类型</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <param name="name">表名、存储过程名等</param>
        /// <param name="parameterList">输入参数数组</param>
        /// <returns>返回数据表</returns>
        public DataTable GetDataTable(SqlQueryType queryType, string dataConStr, string name, params string [] parameterList)
        ...{
            return GetDataTable (GetQueryStr (queryType ,name , parameterList ),dataConStr );
        }

        /**//// <summary>
        /// 返回DataRow
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns>返回DataRow</returns>
        public override DataRow GetDataRow(string sqlStr, string dataConStr)
        ...{
            DataTable returnDt = new DataTable();
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlDataAdapter sqlDa = new SqlDataAdapter(sqlStr, sqlCon);
            try
            ...{
                sqlDa.Fill(0, 1, returnDt);
                return returnDt.Rows[0];
            }
            catch (System.Data.SqlClient.SqlException ex)
            ...{
                throw new Exception(ex.ToString());
            }
            finally
            ...{
                sqlCon.Close();
                sqlDa.Dispose();
                returnDt = null;
            }
        }

        /**//// <summary>
        /// 返回一行数据
        /// </summary>
        /// <param name="queryType">查询类型</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <param name="name">表名、存储过程名等</param>
        /// <param name="parameterList">输入参数数组</param>
        /// <returns></returns>
        public DataRow GetDataRow(SqlQueryType queryType, string dataConStr, string name, params string[] parameterList)
        ...{
            return GetDataRow(GetQueryStr(queryType, name, parameterList), dataConStr);
        }

        /**//// <summary>
        /// 返回DataReader
        /// </summary>
        /// <param name="sqlStr">sql查询语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns>返回DataReader</returns>
        public override object GetDataReader(string sqlStr, string dataConStr)
        ...{
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlCommand sqlCmd = new SqlCommand(sqlStr, sqlCon);
            SqlDataReader sqlDr = null;
            try
            ...{
                sqlCon.Open();
                sqlDr = sqlCmd.ExecuteReader();
                return sqlDr;
            }
            catch (System .Data .SqlClient .SqlException ex)
            ...{
                sqlDr.Close();
                sqlCon.Close();
                sqlCmd.Dispose();
                throw new Exception(ex.ToString());
            }
        }

        /**//// <summary>
        /// 返回一个值
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public override string GetDataFristRC(string sqlStr, string dataConStr)
        ...{
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlCommand sqlCmd = new SqlCommand(sqlStr, sqlCon);
            try
            ...{
                sqlCon.Open();
                return sqlCmd.ExecuteScalar().ToString();
            }
            catch
            ...{
                return null;
            }
            finally
            ...{
                sqlCon.Close();
                sqlCmd.Dispose();
            }
        }

        /**//// <summary>
        /// 执行无返回值操作
        /// </summary>
        /// <param name="sqlStr">sql语句(多个语句用";"分开)</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        public override void ExeNoQuery(string sqlStr, string dataConStr)
        ...{
            SqlConnection sqlCon = new SqlConnection(dataConStr);
            SqlCommand sqlCmd = new SqlCommand(sqlStr, sqlCon);
            try
            ...{
                sqlCon.Open();
                sqlCmd.ExecuteNonQuery();
            }
            catch(System .Data .SqlClient .SqlException ex)
            ...{
                throw new Exception(ex.ToString());
            }
            finally
            ...{
                sqlCon.Close();
                sqlCmd.Dispose();
            }
        }
    }

数据操作工厂类

     public   class  DataControl
     ... {
        AbstractDataControl dataControl = null;

        public DataControl(DataCons dataCons)
        ...{
            switch (dataCons.DataType)
            ...{
                case DataType .SqlServer :
                    dataControl = new SqlDataControl();
                    break;
                case DataType.Access:
                    dataControl = new AccessDataControl();
                    break;
            }
        }

        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public DataSet GetDataSet(string sqlStr, string dataConStr)
        ...{
            return dataControl.GetDataSet(sqlStr, dataConStr);
        }

        /**//// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="queryType"></param>
        /// <param name="dataConStr"></param>
        /// <param name="queryList"></param>
        /// <returns>返回数据集</returns>
        public DataSet GetDataSet(object queryType,string dataConStr, params string[] queryList)
        ...{
            return dataControl.GetDataSet(queryType, dataConStr, queryList);
        }

        /**//// <summary>
        /// 返回数据表
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public DataTable GetDataTable(string sqlStr, string dataConStr)
        ...{
            return dataControl.GetDataTable(sqlStr, dataConStr); 
        }

        /**//// <summary>
        /// 返回数据行
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public DataRow GetDataRow(string sqlStr, string dataConStr)
        ...{
            return dataControl.GetDataRow(sqlStr, dataConStr);
        }

        /**//// <summary>
        /// 返回object型DataReader
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public object GetDataReader(string sqlStr, string dataConStr)
        ...{
            return dataControl.GetDataReader(sqlStr, dataConStr);
        }

        /**//// <summary>
        /// 返回一个值
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        /// <returns></returns>
        public string GetDataFristRC(string sqlStr, string dataConStr)
        ...{
            return dataControl.GetDataFristRC(sqlStr, dataConStr);
        }

        /**//// <summary>
        /// 执行无返回值操作
        /// </summary>
        /// <param name="sqlStr">Sql语句</param>
        /// <param name="dataConStr">数据库连接字符串</param>
        public void ExeNoQuery(string sqlStr, string dataConStr)
        ...{
            dataControl.ExeNoQuery(sqlStr, dataConStr);
        }
    }