我的简单三层架构(另附OracleDbHelper)

初步理解了简单三层架构，觉得它很像java中的ejb，web对应UI，model对应实体bean，bll对应业务bean，毕竟都是你中有我，我中有你。
采用3层架构的好处是：
        维护方便，代码可重用性高，高度应用面向对象方法，而且以上有点在程序越复杂就体现的越加明显。
缺点是：
        开发初期会比较耗费时间，model和bll等类的设计和书写需要全面、缜密。还有就是3层架构的速度会比较慢一些，但是这都瑕不掩瑜了。
Model层：

 1using System;
 2using System.Data;
 3using System.Configuration;
 4using System.Web;
 5using System.Web.Security;
 6using System.Web.UI;
 7using System.Web.UI.WebControls;
 8using System.Web.UI.WebControls.WebParts;
 9using System.Web.UI.HtmlControls;
10
11/**//// <summary>
12/// Role 的摘要说明
13/// </summary>
14public class Role
15{
16    public Role()
17    {
18        //
19        // TODO: 在此处添加构造函数逻辑
20        //
21    }
22
23    Model#region Model
24    private string _role_id;
25    private string _role_name;
26    private string _descn;
27    /**//// <summary>
28    /// 
29    /// </summary>
30    public string ROLE_ID
31    {
32        set { _role_id = value; }
33        get { return _role_id; }
34    }
35    /**//// <summary>
36    /// 
37    /// </summary>
38    public string ROLE_NAME
39    {
40        set { _role_name = value; }
41        get { return _role_name; }
42    }
43    /**//// <summary>
44    /// 
45    /// </summary>
46    public string DESCN
47    {
48        set { _descn = value; }
49        get { return _descn; }
50    }
51    #endregion Model
52}
53

BLL：

using System;
using System.Data;
using .Model;
namespace .BLL
{
    /**//// <summary>
    /// 业务逻辑类TB_ROLE 的摘要说明。
    /// </summary>
    public class TB_ROLE
    {
        private readonly .DAL.TB_ROLE dal=new .DAL.TB_ROLE();
        public TB_ROLE()
        {}
        成员方法#region  成员方法

        /**//// <summary>
        /// 得到最大ID
        /// </summary>
        public int GetMaxId()
        {
            return dal.GetMaxId();
        }

        /**//// <summary>
        /// 是否存在该记录
        /// </summary>
        public bool Exists(VARCHAR2 DESCN)
        {
            return dal.Exists(DESCN);
        }

        /**//// <summary>
        /// 增加一条数据
        /// </summary>
        public string Add(.Model.TB_ROLE model)
        {
            return dal.Add(model);
        }

        /**//// <summary>
        /// 更新一条数据
        /// </summary>
        public void Update(.Model.TB_ROLE model)
        {
            dal.Update(model);
        }

        /**//// <summary>
        /// 删除一条数据
        /// </summary>
        public void Delete(VARCHAR2 DESCN)
        {
            dal.Delete(DESCN);
        }

        /**//// <summary>
        /// 得到一个对象实体
        /// </summary>
        public .Model.TB_ROLE GetModel(VARCHAR2 DESCN)
        {
            return dal.GetModel(DESCN);
        }

        /**//// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetList(string strWhere)
        {
            return dal.GetList(strWhere);
        }

        /**//// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetAllList()
        {
            return dal.GetList("");
        }

        /**//// <summary>
        /// 获得数据列表
        /// </summary>
        //public DataSet GetList(int PageSize,int PageIndex,string strWhere)
        //{
            //return dal.GetList(PageSize,PageIndex,strWhere);
        //}

        #endregion  成员方法
    }
}

DAL：

using System;
using System.Data;
using System.Text;
using System.Data.OracleClient;
using Maticsoft.DBUtility;//请先添加引用
namespace .DAL
{
    /**//// <summary>
    /// 数据访问类TB_ROLE。
    /// </summary>
    public class TB_ROLE
    {
        public TB_ROLE()
        {}
        成员方法#region  成员方法

        /**//// <summary>
        /// 得到最大ID
        /// </summary>
        public int GetMaxId()
        {
            return DbHelperSQL.GetMaxID("DESCN", "TB_ROLE"); 
        }
        /**//// <summary>
        /// 是否存在该记录
        /// </summary>
        public bool Exists(string DESCN)
        {
            StringBuilder strSql=new StringBuilder();
            strSql.Append("select count(1) from TB_ROLE");
            strSql.Append(" where DESCN= @DESCN");
            OracleParameter[] parameters = {
                    new OracleParameter("@DESCN", OracleType.VarChar)
                };
            parameters[0].Value = DESCN;
            return DbHelperSQL.Exists(strSql.ToString(),parameters);
        }


        /**//// <summary>
        /// 增加一条数据
        /// </summary>
        public string Add(.Model.TB_ROLE model)
        {
            //model.DESCN=GetMaxId();
            StringBuilder strSql=new StringBuilder();
            strSql.Append("insert into TB_ROLE(");
            strSql.Append("ROLE_ID,ROLE_NAME,DESCN)");
            strSql.Append(" values (");
            strSql.Append("@ROLE_ID,@ROLE_NAME,@DESCN)");
            OracleParameter[] parameters = {
                    new OracleParameter("@ROLE_ID", OracleType.VarChar,8),
                    new OracleParameter("@ROLE_NAME", OracleType.VarChar,20),
                    new OracleParameter("@DESCN", OracleType.VarChar,20)};
            parameters[0].Value = model.ROLE_ID;
            parameters[1].Value = model.ROLE_NAME;
            parameters[2].Value = model.DESCN;

            DbHelperSQL.ExecuteSql(strSql.ToString(),parameters);
            return model.DESCN;
        }
        /**//// <summary>
        /// 更新一条数据
        /// </summary>
        public void Update(.Model.TB_ROLE model)
        {
            StringBuilder strSql=new StringBuilder();
            strSql.Append("update TB_ROLE set ");
            strSql.Append("ROLE_ID=@ROLE_ID,");
            strSql.Append("ROLE_NAME=@ROLE_NAME");
            strSql.Append(" where DESCN=@DESCN");
            OracleParameter[] parameters = {
                    new OracleParameter("@ROLE_ID", OracleType.VarChar,8),
                    new OracleParameter("@ROLE_NAME", OracleType.VarChar,20),
                    new OracleParameter("@DESCN", OracleType.VarChar,20)};
            parameters[0].Value = model.ROLE_ID;
            parameters[1].Value = model.ROLE_NAME;
            parameters[2].Value = model.DESCN;

            DbHelperSQL.ExecuteSql(strSql.ToString(),parameters);
        }

        /**//// <summary>
        /// 删除一条数据
        /// </summary>
        public void Delete(string DESCN)
        {
            StringBuilder strSql=new StringBuilder();
            strSql.Append("delete TB_ROLE ");
            strSql.Append(" where DESCN=@DESCN");
            OracleParameter[] parameters = {
                    new OracleParameter("@DESCN", OracleType.VarChar)
                };
            parameters[0].Value = DESCN;
            DbHelperSQL.ExecuteSql(strSql.ToString(),parameters);
        }


        /**//// <summary>
        /// 得到一个对象实体
        /// </summary>
        public .Model.TB_ROLE GetModel(string DESCN)
        {
            StringBuilder strSql=new StringBuilder();
            strSql.Append("select * from TB_ROLE ");
            strSql.Append(" where DESCN=@DESCN");
            OracleParameter[] parameters = {
                    new OracleParameter("@DESCN", OracleType.VarChar)};
            parameters[0].Value = DESCN;
            .Model.TB_ROLE model=new .Model.TB_ROLE();
            DataSet ds=DbHelperSQL.Query(strSql.ToString(),parameters);
            model.DESCN=DESCN;
            if(ds.Tables[0].Rows.Count>0)
            {
                model.ROLE_ID=ds.Tables[0].Rows[0]["ROLE_ID"].ToString();
                model.ROLE_NAME=ds.Tables[0].Rows[0]["ROLE_NAME"].ToString();
                return model;
            }
            else
            {
            return null;
            }
        }
        /**//// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetList(string strWhere)
        {
            StringBuilder strSql=new StringBuilder();
            strSql.Append("select [ROLE_ID],[ROLE_NAME],[DESCN] ");
            strSql.Append(" FROM TB_ROLE ");
            if(strWhere.Trim()!="")
            {
                strSql.Append(" where "+strWhere);
            }
            return DbHelperSQL.Query(strSql.ToString());
        }

        /**//*
        /// <summary>
        /// 分页获取数据列表
        /// </summary>
        public DataSet GetList(int PageSize,int PageIndex,string strWhere)
        {
            OracleParameter[] parameters = {
                    new OracleParameter("@tblName", OracleType.VarChar, 255),
                    new OracleParameter("@fldName", OracleType.VarChar, 255),
                    new OracleParameter("@PageSize", OracleType.Number),
                    new OracleParameter("@PageIndex", OracleType.Number),
                    new OracleParameter("@IsReCount", OracleType.Clob),
                    new OracleParameter("@OrderType", OracleType.Clob),
                    new OracleParameter("@strWhere", OracleType.VarChar,1000),
                    };
            parameters[0].Value = "TB_ROLE";
            parameters[1].Value = "DESCN";
            parameters[2].Value = PageSize;
            parameters[3].Value = PageIndex;
            parameters[4].Value = 0;
            parameters[5].Value = 0;
            parameters[6].Value = strWhere;    
            return DbHelperSQL.RunProcedure("UP_GetRecordByPage",parameters,"ds");
        }*/

        #endregion  成员方法
    }
}

以上代码由李天平先生的 动软代码自动生成器生成。
但是其中需要将sql参数@改成:，还有就是这个生成器生成的主键有些问题。但它还是可以极大的提高我们的工作效率，在这里感谢李先生。

另附由sqlserver改成oracle数据库可能用到的DbHelper.cs,希望能对大家有些帮助：

  1using System;
  2using System.Data;
  3using System.Configuration;
  4using System.Collections;
  5using System.Web;
  6using System.Web.Security;
  7using System.Web.UI;
  8using System.Web.UI.WebControls;
  9using System.Web.UI.WebControls.WebParts;
 10using System.Web.UI.HtmlControls;
 11using System.Text;
 12using System.Data.OracleClient;
 13
 14/**//// <summary>
 15/// DbHelperSQL 的摘要说明
 16/// 修改自Sql版本DbHelperSQL
 17/// 07-08-06修改
 18/// </summary>
 19public abstract class DbHelperSQL
 20{
 21      public DbHelperSQL()
 22    {
 23        //
 24        // TODO: 在此处添加构造函数逻辑
 25        //
 26    }
 27
 28    公用方法#region 公用方法
 29
 30    public static string GetMaxID(string FieldName, string TableName)
 31    {
 32        string strsql = "select max(" + FieldName + ")+1 from " + TableName;
 33        object obj = DbHelperSQL.GetSingle(strsql);
 34        if (obj == null)
 35        {
 36            return "1";
 37        }
 38        else
 39        {
 40
 41            return obj.ToString();
 42        }
 43    }
 44   
 45    public static bool Exists(string strSql)
 46    {
 47        object obj = DbHelperSQL.GetSingle(strSql);
 48        int cmdresult;
 49        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 50        {
 51            cmdresult = 0;
 52        }
 53        else
 54        {
 55            cmdresult = int.Parse(obj.ToString());
 56        }
 57        if (cmdresult == 0)
 58        {
 59            return false;
 60        }
 61        else
 62        {
 63            return true;
 64        }
 65    }
 66
 67    public static bool Exists(string strSql, params OracleParameter[] cmdParms)
 68    {
 69        object obj = DbHelperSQL.GetSingle(strSql, cmdParms);
 70        int cmdresult;
 71        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 72        {
 73            cmdresult = 0;
 74        }
 75        else
 76        {
 77            cmdresult = int.Parse(obj.ToString());
 78        }
 79        if (cmdresult == 0)
 80        {
 81            return false;
 82        }
 83        else
 84        {
 85            return true;
 86        }
 87    }
 88    #endregion
 89
 90    执行简单SQL语句#region  执行简单SQL语句
 91
 92    /**//// <summary>
 93    /// 执行SQL语句，返回影响的记录数
 94    /// </summary>
 95    /// <param name="SQLString">SQL语句</param>
 96    /// <returns>影响的记录数</returns>
 97    public static int ExecuteSql(string SQLString)
 98    {
 99        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
100        {
101            using (OracleCommand cmd = new OracleCommand(SQLString, connection))
102            {
103                try
104                {
105                    connection.Open();
106                    int rows = cmd.ExecuteNonQuery();
107                    return rows;
108                }
109                catch (System.Data.OracleClient.OracleException E)
110                {
111                    connection.Close();
112                    throw new Exception(E.Message);
113                }
114            }
115        }
116    }
117    //public string ExecuteSql(string SQLString)
118    //{
119    //    using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
120    //    {
121    //        using (OracleCommand cmd = new OracleCommand(SQLString, connection))
122    //        {
123    //            try
124    //            {
125    //                connection.Open();
126    //                int rows = cmd.ExecuteNonQuery();
127    //                return rows;
128    //            }
129    //            catch (System.Data.OracleClient.OracleException E)
130    //            {
131    //                connection.Close();
132    //                throw new Exception(E.Message);
133    //            }
134    //        }
135    //    }
136    //}
137    /**//// <summary>
138    /// 执行SQL语句，设置命令的执行等待时间
139    /// </summary>
140    /// <param name="SQLString"></param>
141    /// <param name="Times"></param>
142    /// <returns></returns>
143    public static int ExecuteSqlByTime(string SQLString, int Times)
144    {
145        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
146        {
147            using (OracleCommand cmd = new OracleCommand(SQLString, connection))
148            {
149                try
150                {
151                    connection.Open();
152                    cmd.CommandTimeout = Times;
153                    int rows = cmd.ExecuteNonQuery();
154                    return rows;
155                }
156                catch (System.Data.OracleClient.OracleException E)
157                {
158                    connection.Close();
159                    throw new Exception(E.Message);
160                }
161            }
162        }
163    }
164
165    /**//// <summary>
166    /// 执行多条SQL语句，实现数据库事务。
167    /// </summary>
168    /// <param name="SQLStringList">多条SQL语句</param>        
169    public static void ExecuteSqlTran(ArrayList SQLStringList)
170    {
171        using (OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
172        {
173            conn.Open();
174            OracleCommand cmd = new OracleCommand();
175            cmd.Connection = conn;
176            OracleTransaction tx = conn.BeginTransaction();
177            cmd.Transaction = tx;
178            try
179            {
180                for (int n = 0; n < SQLStringList.Count; n++)
181                {
182                    string strsql = SQLStringList[n].ToString();
183                    if (strsql.Trim().Length > 1)
184                    {
185                        cmd.CommandText = strsql;
186                        cmd.ExecuteNonQuery();
187                    }
188                }
189                tx.Commit();
190            }
191            catch (System.Data.OracleClient.OracleException E)
192            {
193                tx.Rollback();
194                throw new Exception(E.Message);
195            }
196        }
197    }
198    /**//// <summary>
199    /// 执行带一个存储过程参数的的SQL语句。
200    /// </summary>
201    /// <param name="SQLString">SQL语句</param>
202    /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
203    /// <returns>影响的记录数</returns>
204    public static int ExecuteSql(string SQLString, string content)
205    {
206        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
207        {
208            OracleCommand cmd = new OracleCommand(SQLString, connection);
209            System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter(":content", SqlDbType.NText);
210            myParameter.Value = content;
211            cmd.Parameters.Add(myParameter);
212            try
213            {
214                connection.Open();
215                int rows = cmd.ExecuteNonQuery();
216                return rows;
217            }
218            catch (System.Data.OracleClient.OracleException E)
219            {
220                throw new Exception(E.Message);
221            }
222            finally
223            {
224                cmd.Dispose();
225                connection.Close();
226            }
227        }
228    }
229    /**//// <summary>
230    /// 执行带一个存储过程参数的的SQL语句。
231    /// </summary>
232    /// <param name="SQLString">SQL语句</param>
233    /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
234    /// <returns>影响的记录数</returns>
235    public static object ExecuteSqlGet(string SQLString, string content)
236    {
237        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
238        {
239            OracleCommand cmd = new OracleCommand(SQLString, connection);
240            System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter(":content", SqlDbType.NText);
241            myParameter.Value = content;
242            cmd.Parameters.Add(myParameter);
243            try
244            {
245                connection.Open();
246                object obj = cmd.ExecuteScalar();
247                if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
248                {
249                    return null;
250                }
251                else
252                {
253                    return obj;
254                }
255            }
256            catch (System.Data.OracleClient.OracleException E)
257            {
258                throw new Exception(E.Message);
259            }
260            finally
261            {
262                cmd.Dispose();
263                connection.Close();
264            }
265        }
266    }
267    /**//// <summary>
268    /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
269    /// </summary>
270    /// <param name="strSQL">SQL语句</param>
271    /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
272    /// <returns>影响的记录数</returns>
273    public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
274    {
275        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString())))
276        {
277            OracleCommand cmd = new OracleCommand(strSQL, connection);
278            System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter(":fs", SqlDbType.Image);
279            myParameter.Value = fs;
280            cmd.Parameters.Add(myParameter);
281            try
282            {
283                connection.Open();
284                int rows = cmd.ExecuteNonQuery();
285                return rows;
286            }
287            catch (System.Data.OracleClient.OracleException E)
288            {
289                throw new Exception(E.Message);
290            }
291            finally
292            {
293                cmd.Dispose();
294                connection.Close();
295            }
296        }
297    }
298
299    /**//// <summary>
300    /// 执行一条计算查询结果语句，返回查询结果（object）。
301    /// </summary>
302    /// <param name="SQLString">计算查询结果语句</param>
303    /// <returns>查询结果（object）</returns>
304    public static object GetSingle(string SQLString)
305    {
306        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
307        {
308            using (OracleCommand cmd = new OracleCommand(SQLString, connection))
309            {
310                try
311                {
312                    connection.Open();
313                    object obj = cmd.ExecuteScalar();
314                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
315                    {
316                        return null;
317                    }
318                    else
319                    {
320                        return obj;
321                    }
322                }
323                catch (System.Data.OracleClient.OracleException e)
324                {
325                    connection.Close();
326                    throw new Exception(e.Message);
327                }
328            }
329        }
330    }
331
332
333    /**//// <summary>
334    /// 执行查询语句，返回SqlDataReader(使用该方法切记要手工关闭SqlDataReader和连接)
335    /// </summary>
336    /// <param name="strSQL">查询语句</param>
337    /// <returns>SqlDataReader</returns>
338    public static OracleDataReader ExecuteReader(string strSQL)
339    {
340        OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()));
341        OracleCommand cmd = new OracleCommand(strSQL, connection);
342        try
343        {
344            connection.Open();
345            OracleDataReader myReader = cmd.ExecuteReader();
346            return myReader;
347        }
348        catch (System.Data.OracleClient.OracleException e)
349        {
350            throw new Exception(e.Message);
351        }
352        //finally //不能在此关闭，否则，返回的对象将无法使用
353        //{
354        //    cmd.Dispose();
355        //    connection.Close();
356        //}    
357
358
359    }
360    /**//// <summary>
361    /// 执行查询语句，返回DataSet
362    /// </summary>
363    /// <param name="SQLString">查询语句</param>
364    /// <returns>DataSet</returns>
365    public static DataSet Query(string SQLString)
366    {
367        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
368        {
369            DataSet ds = new DataSet();
370            try
371            {
372                connection.Open();
373                OracleDataAdapter command = new OracleDataAdapter(SQLString, connection);
374                command.Fill(ds, "ds");
375            }
376            catch (System.Data.OracleClient.OracleException ex)
377            {
378                throw new Exception(ex.Message);
379            }
380            return ds;
381        }
382    }
383    /**//// <summary>
384    /// 执行查询语句，返回DataSet,设置命令的执行等待时间
385    /// </summary>
386    /// <param name="SQLString"></param>
387    /// <param name="Times"></param>
388    /// <returns></returns>
389    public static DataSet Query(string SQLString, int Times)
390    {
391        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
392        {
393            DataSet ds = new DataSet();
394            try
395            {
396                connection.Open();
397                OracleDataAdapter command = new OracleDataAdapter(SQLString, connection);
398                command.SelectCommand.CommandTimeout = Times;
399                command.Fill(ds, "ds");
400            }
401            catch (System.Data.OracleClient.OracleException ex)
402            {
403                throw new Exception(ex.Message);
404            }
405            return ds;
406        }
407    }
408
409
410
411    #endregion
412
413    执行带参数的SQL语句#region 执行带参数的SQL语句
414
415    /**//// <summary>
416    /// 执行SQL语句，返回影响的记录数
417    /// </summary>
418    /// <param name="SQLString">SQL语句</param>
419    /// <returns>影响的记录数</returns>
420    public static int ExecuteSql(string SQLString, params OracleParameter[] cmdParms)
421    {
422        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
423        {
424            using (OracleCommand cmd = new OracleCommand())
425            {
426                try
427                {
428                    PrepareCommand(cmd, connection, null, SQLString, cmdParms);
429                    int rows = cmd.ExecuteNonQuery();
430                    cmd.Parameters.Clear();
431                    return rows;
432                }
433                catch (System.Data.OracleClient.OracleException E)
434                {
435                    throw new Exception(E.Message);
436                }
437            }
438        }
439    }
440
441
442    /**//// <summary>
443    /// 执行多条SQL语句，实现数据库事务。
444    /// </summary>
445    /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
446    public static void ExecuteSqlTran(Hashtable SQLStringList)
447    {
448
449        using (OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
450        {
451            conn.Open();
452            using (OracleTransaction trans = conn.BeginTransaction())
453            {
454                OracleCommand cmd = new OracleCommand();
455                try
456                {
457                    //循环
458                    foreach (DictionaryEntry myDE in SQLStringList)
459                    {
460                        string cmdText = myDE.Key.ToString();
461                        OracleParameter[] cmdParms = (OracleParameter[])myDE.Value;
462                        PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
463                        int val = cmd.ExecuteNonQuery();
464                        cmd.Parameters.Clear();
465
466                        trans.Commit();
467                    }
468                }
469                catch
470                {
471                    trans.Rollback();
472                    throw;
473                }
474            }
475        }
476    }
477
478
479    /**//// <summary>
480    /// 执行一条计算查询结果语句，返回查询结果（object）。
481    /// </summary>
482    /// <param name="SQLString">计算查询结果语句</param>
483    /// <returns>查询结果（object）</returns>
484    public static object GetSingle(string SQLString, params OracleParameter[] cmdParms)
485    {
486        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
487        {
488            using (OracleCommand cmd = new OracleCommand())
489            {
490                try
491                {
492                    PrepareCommand(cmd, connection, null, SQLString, cmdParms);
493                    object obj = cmd.ExecuteScalar();
494                    cmd.Parameters.Clear();
495                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
496                    {
497                        return null;
498                    }
499                    else
500                    {
501                        return obj;
502                    }
503                }
504                catch (System.Data.OracleClient.OracleException e)
505                {
506                    throw new Exception(e.Message);
507                }
508            }
509        }
510    }
511
512    /**//// <summary>
513    /// 执行查询语句，返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
514    /// </summary>
515    /// <param name="strSQL">查询语句</param>
516    /// <returns>SqlDataReader</returns>
517    public static OracleDataReader ExecuteReader(string SQLString, params OracleParameter[] cmdParms)
518    {
519        OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString());
520        OracleCommand cmd = new OracleCommand();
521        try
522        {
523            PrepareCommand(cmd, connection, null, SQLString, cmdParms);
524            OracleDataReader myReader = cmd.ExecuteReader();
525            cmd.Parameters.Clear();
526            return myReader;
527        }
528        catch (System.Data.OracleClient.OracleException e)
529        {
530            throw new Exception(e.Message);
531        }
532        //finally //不能在此关闭，否则，返回的对象将无法使用
533        //{
534        //    cmd.Dispose();
535        //    connection.Close();
536        //}    
537
538    }
539
540    /**//// <summary>
541    /// 执行查询语句，返回DataSet
542    /// </summary>
543    /// <param name="SQLString">查询语句</param>
544    /// <returns>DataSet</returns>
545    public static DataSet Query(string SQLString, params OracleParameter[] cmdParms)
546    {
547        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
548        {
549            OracleCommand cmd = new OracleCommand();
550            PrepareCommand(cmd, connection, null, SQLString, cmdParms);
551            using (OracleDataAdapter da = new OracleDataAdapter(cmd))
552            {
553                DataSet ds = new DataSet();
554                try
555                {
556                    da.Fill(ds, "ds");
557                    cmd.Parameters.Clear();
558                }
559                catch (System.Data.OracleClient.OracleException ex)
560                {
561                    throw new Exception(ex.Message);
562                }
563                return ds;
564            }
565        }
566    }
567
568
569    private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trans, string cmdText, OracleParameter[] cmdParms)
570    {
571        if (conn.State != ConnectionState.Open)
572            conn.Open();
573        cmd.Connection = conn;
574        cmd.CommandText = cmdText;
575        if (trans != null)
576            cmd.Transaction = trans;
577        cmd.CommandType = CommandType.Text;//cmdType;
578        if (cmdParms != null)
579        {
580
581
582            foreach (OracleParameter parameter in cmdParms)
583            {
584                if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
585                    (parameter.Value == null))
586                {
587                    parameter.Value = DBNull.Value;
588                }
589                cmd.Parameters.Add(parameter);
590            }
591        }
592    }
593    /**//// <summary>
594    /// 
595    /// </summary>
596    /// <param name="strQuery"></param>
597    /// <returns></returns>
598    public static bool ExecSQL(string strQuery)
599    {
600        OracleConnection conn = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString());
601        conn.Open();
602        OracleCommand cmd = new OracleCommand(strQuery, conn);
603
604        try
605        {
606            cmd.ExecuteNonQuery();
607            conn.Close();
608        }
609        catch
610        {
611            conn.Close();
612            return false;
613        }
614        return true;
615    }
616    #endregion
617
618    存储过程操作#region 存储过程操作
619
620    /**//// <summary>
621    /// 执行存储过程  (使用该方法切记要手工关闭SqlDataReader和连接)
622    /// </summary>
623    /// <param name="storedProcName">存储过程名</param>
624    /// <param name="parameters">存储过程参数</param>
625    /// <returns>SqlDataReader</returns>
626    public static OracleDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
627    {
628        OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()));
629        OracleDataReader returnReader;
630        connection.Open();
631        OracleCommand command = BuildQueryCommand(connection, storedProcName, parameters);
632        command.CommandType = CommandType.StoredProcedure;
633        returnReader = command.ExecuteReader();
634        //Connection.Close(); 不能在此关闭，否则，返回的对象将无法使用            
635        return returnReader;
636
637    }
638
639
640    /**//// <summary>
641    /// 执行存储过程
642    /// </summary>
643    /// <param name="storedProcName">存储过程名</param>
644    /// <param name="parameters">存储过程参数</param>
645    /// <param name="tableName">DataSet结果中的表名</param>
646    /// <returns>DataSet</returns>
647    public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
648    {
649        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
650        {
651            DataSet dataSet = new DataSet();
652            connection.Open();
653            OracleDataAdapter sqlDA = new OracleDataAdapter();
654            sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
655            sqlDA.Fill(dataSet, tableName);
656            connection.Close();
657            return dataSet;
658        }
659    }
660    public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
661    {
662        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
663        {
664            DataSet dataSet = new DataSet();
665            connection.Open();
666            OracleDataAdapter sqlDA = new OracleDataAdapter();
667            sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
668            sqlDA.SelectCommand.CommandTimeout = Times;
669            sqlDA.Fill(dataSet, tableName);
670            connection.Close();
671            return dataSet;
672        }
673    }
674
675
676    /**//// <summary>
677    /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
678    /// </summary>
679    /// <param name="connection">数据库连接</param>
680    /// <param name="storedProcName">存储过程名</param>
681    /// <param name="parameters">存储过程参数</param>
682    /// <returns>SqlCommand</returns>
683    private static OracleCommand BuildQueryCommand(OracleConnection connection, string storedProcName, IDataParameter[] parameters)
684    {
685        OracleCommand command = new OracleCommand(storedProcName, connection);
686        command.CommandType = CommandType.StoredProcedure;
687        foreach (OracleParameter parameter in parameters)
688        {
689            if (parameter != null)
690            {
691                // 检查未分配值的输出参数,将其分配以DBNull.Value.
692                if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
693                    (parameter.Value == null))
694                {
695                    parameter.Value = DBNull.Value;
696                }
697                command.Parameters.Add(parameter);
698            }
699        }
700
701        return command;
702    }
703
704    /**//// <summary>
705    /// 执行存储过程，返回影响的行数        
706    /// </summary>
707    /// <param name="storedProcName">存储过程名</param>
708    /// <param name="parameters">存储过程参数</param>
709    /// <param name="rowsAffected">影响的行数</param>
710    /// <returns></returns>
711    public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
712    {
713        using (OracleConnection connection = new OracleConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString()))
714        {
715            int result;
716            connection.Open();
717            OracleCommand command = BuildIntCommand(connection, storedProcName, parameters);
718            rowsAffected = command.ExecuteNonQuery();
719            result = (int)command.Parameters["ReturnValue"].Value;
720            //Connection.Close();
721            return result;
722        }
723    }
724
725    /**//// <summary>
726    /// 创建 SqlCommand 对象实例(用来返回一个整数值)    
727    /// </summary>
728    /// <param name="storedProcName">存储过程名</param>
729    /// <param name="parameters">存储过程参数</param>
730    /// <returns>SqlCommand 对象实例</returns>
731    private static OracleCommand BuildIntCommand(OracleConnection connection, string storedProcName, IDataParameter[] parameters)
732    {
733        OracleCommand command = BuildQueryCommand(connection, storedProcName, parameters);
734        command.Parameters.Add(new OracleParameter("ReturnValue",
735            OracleType.VarChar, 4, ParameterDirection.ReturnValue,
736            false, 0, 0, string.Empty, DataRowVersion.Default, null));
737        return command;
738    }
739    #endregion
740}
741