通用数据访问类

最新推荐文章于 2023-01-11 09:44:54 发布
最新推荐文章于 2023-01-11 09:44:54 发布
阅读量86 收藏
点赞数
原文链接：http://www.cnblogs.com/angushine/archive/2008/12/06/1348885.html
版权

///   <summary>
///  Summary description for BaseBLL.
 ///   </summary>
public   class  BaseBLL
{
     private   string  connectionString  =   "" ;
     private   int  timeout  =   180 ;
     private   string  connectionKey  =   " HUANG_SQLCONNECTION " ;
     private   string  transactionKey  =   " HUANG_SQLTRANSACTION " ;

     public  BaseBLL()
    {
        connectionString  =  ConfigurationSettings.AppSettings[ " connectionString " ];
        timeout  =   int .Parse(ConfigurationSettings.AppSettings[ " timeout " ]);
    }

     #region  Properties

     private  SqlConnection Connection
    {
         get  
        {
             // System.Web.HttpContext.Current.Response.Write(HttpContext.Current.Session.SessionID + "<br/>");
            SqlConnection connection  =  (SqlConnection)DataCache.GetSession(connectionKey);
             if  (connection  ==   null )
            {
                DataCache.SetSession(connectionKey,  new  SqlConnection(connectionString));
            }
            connection  =  (SqlConnection)DataCache.GetSession(connectionKey);
             if  (connection.State  ==  ConnectionState.Closed)
            {
                connection.Open();
            }
             return  connection;
        }
         set  
        {
            DataCache.SetSession(connectionKey, value); 
        }
    }

     private  SqlTransaction Transaction
    {
         get  {  return  (SqlTransaction)DataCache.GetSession(transactionKey); }
         set  { DataCache.SetSession(transactionKey, value); }
    }

     #endregion

     #region  ExecuteNonQuery

     protected   int  ExecuteNonQuery(SqlCommand command)
    {
         //  当没有开启事务时，执行之后关闭连接，否则在提交事务或者回滚事务中关闭连接。
         bool  closeConnection  =   true ;
         try
        {
            command.Connection  =  Connection;
            command.CommandTimeout  =  timeout;
            SqlTransaction transaction  =  Transaction;
             if  (transaction  !=   null )
            {
                command.Transaction  =  transaction;
                closeConnection  =   false ;
            }
             return  command.ExecuteNonQuery();
        }
         catch  (Exception ex)
        {
             throw  ex;
        }
         finally
        {
            command.Parameters.Clear();
             if  (closeConnection  &&  command.Connection.State  ==  ConnectionState.Open)
            {
                command.Connection.Close();
            }
        }
    }

     #endregion

     #region  ExecuteScalar

     protected   object  ExecuteScalar(SqlCommand command)
    {
         //  当没有开启事务时，执行之后关闭连接，否则在提交事务或者回滚事务中关闭连接。
         bool  closeConnection  =   true ;
         try
        {
            command.Connection  =  Connection;
            command.CommandTimeout  =  timeout;
            SqlTransaction transaction  =  Transaction;
             if  (transaction  !=   null )
            {
                command.Transaction  =  transaction;
                closeConnection  =   false ;
            }
             return  command.ExecuteScalar();
        }
         catch  (Exception ex)
        {
             throw  ex;
        }
         finally
        {
            command.Parameters.Clear();
             if  (closeConnection  &&  command.Connection.State  ==  ConnectionState.Open)
            {
                command.Connection.Close();
            }
        }
    }

     #endregion

     #region  ExecuteReader

     public  SqlDataReader ExecuteReader( string  commandText, CommandBehavior behavior)
    {
        SqlConnection conn  =   new  SqlConnection(connectionString);
         using  (SqlCommand command  =   new  SqlCommand(commandText, conn))
        {
            command.CommandTimeout  =  timeout;
             if  (conn.State  ==  ConnectionState.Closed)
            {
                conn.Open();
            }
            
             try
            {
                 return  command.ExecuteReader(behavior);
            }
             catch
            {
                 throw ;
            }
        }
    }

     protected  SqlDataReader ExecuteReader(SqlCommand command)
    {
         try
        {
            SqlConnection conn  =   new  SqlConnection(connectionString);
             if  (conn.State  ==  ConnectionState.Closed)
            {
                conn.Open();
            }
            command.Connection  =  conn;
            command.CommandTimeout  =  timeout;
            SqlDataReader reader  =  command.ExecuteReader(CommandBehavior.CloseConnection);
            command.Parameters.Clear();
             return  reader;
        }
         catch  (Exception ex)
        {
             throw  ex;
        }
    }
    
     #endregion

     #region  ExecuteDataSet

     protected  DataSet ExecuteDataSet(SqlCommand command)
    {
        command.Connection  =  Connection;
        command.CommandTimeout  =  timeout;
        SqlDataAdapter da  =   new  SqlDataAdapter(command);
        DataSet ds  =   new  DataSet();
        da.Fill(ds);
        command.Parameters.Clear();
         //  关闭连接
         if  (Connection.State  ==  ConnectionState.Open)
        {
            Connection.Close();
        }
         return  ds;
    }

     public  DataTable ExecuteDataTable( string  sql,  int  pageNo,  int  pageSize,  out   int  pageCount,  out   int  rowCount)
    {
         string  commandText  =   @"
            DECLARE @p1 INT,@RowCount INT,@PageCount INT
            EXEC sp_cursoropen 
                @cursor = @p1 OUTPUT, 
                @stmt = @sql, 
                @scrollopt = 1, 
                @ccopt = 1, 
                @rowcount = @RowCount OUTPUT
            IF @PageSize = -1
            BEGIN
                -- 显示页码
                SELECT 1 AS [PageCount], @RowCount AS [RowCount]
                EXEC(@sql)
            END
            ELSE
            BEGIN
                SET @PageNo = @PageNo + 1
                -- 计算总页数
                IF @PageSize < 1 
                    SET @PageSize = 10
                SET @PageCount = (@RowCount + @PageSize - 1) / @PageSize
                IF ISNULL(@PageNo, 0) < 1 
                    SET @PageNo = 1
                ELSE IF ISNULL(@PageNo, 0) > @PageCount
                    SET @PageNo = @PageCount
                SET @PageNo = (@PageNo - 1) * @PageSize + 1
                -- 显示页码
                SELECT @PageCount AS [PageCount], @RowCount AS [RowCount]
                -- 显示指定页的数据
                EXEC sp_cursorfetch @p1, 16, @PageNo, @PageSize
            END
            --关闭分页游标
            EXEC sp_cursorclose @p1
         " ;
        SqlCommand cmd  =   new  SqlCommand(commandText, Connection);
        cmd.Parameters.Add( new  SqlParameter( " @sql " , sql));
        cmd.Parameters.Add( new  SqlParameter( " @PageNo " , pageNo));
        cmd.Parameters.Add( new  SqlParameter( " @PageSize " , pageSize));
        DataSet ds  =  ExecuteDataSet(cmd);
        rowCount  =  (Int32)ds.Tables[ 1 ].Rows[ 0 ][ " RowCount " ];
        pageCount  =  (Int32)ds.Tables[ 1 ].Rows[ 0 ][ " PageCount " ];
         return  ds.Tables[ 2 ];
    }

     public  DataSet ExecuteDataSet( string  sql,  int  startRecord,  int  maxRecords,  string  srcTable)
    {
         return  ExecuteDataSet( new  SqlCommand(sql), startRecord, maxRecords, srcTable);
    }

     protected  DataSet ExecuteDataSet(SqlCommand command,  int  startRecord,  int  maxRecords,  string  srcTable)
    {
        command.Connection  =  Connection;
        command.CommandTimeout  =  timeout;
        SqlDataAdapter da  =   new  SqlDataAdapter(command);
        DataSet ds  =   new  DataSet();
         int  count  =  da.Fill(ds, startRecord, maxRecords, srcTable);
        command.Parameters.Clear();
         //  关闭连接
         if  (Connection.State  ==  ConnectionState.Open)
        {
            Connection.Close();
        }
         return  ds;
    }

     #endregion  ExecuteDataSet

     #region  CRUD

     ///   <summary>
     ///  返回总行数
     ///   </summary>
     ///   <param name="table"></param>
     ///   <param name="where"></param>
     ///   <returns></returns>
     public   int  GetRowCounts( string  table,  string   where )
    {
         string  sql  =   string .Format( " SELECT COUNT(1) FROM {0} WHERE {1} " , table,  where );
         return  ( int )ExecuteScalar( new  SqlCommand(sql));
    }

     ///   <summary>
     ///  新建一行
     ///   </summary>
     ///   <param name="table"></param>
     ///   <returns></returns>
     public  DataRow NewDataRow( string  table)
    {
         string  sql  =   string .Format( " SELECT * FROM {0} WHERE 1=2 " , table);
        DataSet ds  =  ExecuteDataSet( new  SqlCommand(sql));
         if  (ds.Tables.Count  >   0 )
             return  ds.Tables[ 0 ].NewRow();
         else
             throw   new  Exception( " Cann't new a datarow. " );
    }
    
     private  DataTable GeCacheSchema( string  key)
    {
        DataTable dt  =  (DataTable)DataCache.GetCache(key  +   " _Schema " );
         if  (dt  ==   null )
        {
             string  sql  =   " select top 1 * from [ "   +  key  +   " ] " ;

            SqlDataReader reader  =  ExecuteReader(sql, CommandBehavior.CloseConnection  |  CommandBehavior.KeyInfo);
            dt  =  reader.GetSchemaTable();
            reader.Close();
            DataCache.SetCache(key  +   " _Schema " , dt);
        }
         return  dt;
    }

     ///   <summary>
     ///  增加
     ///   </summary>
     ///   <param name="tableName"></param>
     ///   <param name="row"></param>
     ///   <returns></returns>
     public   int  Create( string  tableName, DataRow row)
    {
        StringBuilder sb1  =   new  StringBuilder();
        StringBuilder sb2  =   new  StringBuilder();
        sb1.Append( " INSERT INTO [ "   +  tableName  +   " ]( " );
        sb2.Append( " VALUES( " );
        DataTable dt  =  GeCacheSchema(tableName);
         bool  isIdentity;
         string  baseName;
         object  data;
        ArrayList parameters  =   new  ArrayList();
         foreach  (DataRow dr  in  dt.Rows)
        {
            isIdentity  =  Convert.ToBoolean(dr[ " IsIdentity " ]);
            baseName  =  Convert.ToString(dr[ " BaseColumnName " ]);
            data  =  row[baseName];
             if  (data  !=  DBNull.Value  &&   ! isIdentity)
            {
                 if  (sb1[sb1.Length  -   1 ]  ==   ' ( ' )
                {
                    sb1.Append( " [ "   +  baseName  +   " ] " );
                    sb2.Append( " @ "   +  baseName);
                }
                 else
                {
                    sb1.Append( " , [ "   +  baseName  +   " ] " );
                    sb2.Append( " , @ "   +  baseName);
                }
                parameters.Add( new  SqlParameter( " @ "   +  baseName, data));
            }
        }

        sb1.Append( " ) " );
        sb2.Append( " ) " );
        sb1.Append( "   "   +  sb2.ToString());

         try
        {
            SqlCommand command  =   new  SqlCommand(sb1.ToString());
            command.CommandTimeout  =  timeout;
             foreach  (SqlParameter p  in  parameters)
            {
                command.Parameters.Add(p);
            }
             return  ExecuteNonQuery(command);
        }
         catch
        {
             throw ;
        }
    }
    
     ///   <summary>
     ///  检索
     ///   </summary>
     ///   <param name="table"></param>
     ///   <param name="key"></param>
     ///   <param name="values"></param>
     ///   <returns></returns>
     public  DataTable Retrieve( string  table,  string  key,  object [] values)
    {
         return  Retrieve(table, key, values,  "" );
    }

     public  DataTable Retrieve( string  table,  string  key,  object [] values,  string  sort)
    {
         return  Retrieve(table, key, values,  " * " , sort);
    }

     public  DataTable Retrieve( string  table,  string  key,  object [] values,  string  columns,  string  sort)
    {
        key  =  key.ToLower();
        StringBuilder sb1  =   new  StringBuilder();
         string  head  =   string .Format( " SELECT {1} FROM {0} WHERE 1=1  " , table, (columns  ==   null   ||  columns.Trim()  ==   "" )  ?   " * "  : columns);
        sb1.Append(head);
        ArrayList parameters  =   new  ArrayList();
         string [] ss  =  key.Split( ' , ' );
         for ( int  i  = 0 ; i  <  ss.Length; i  ++ )
        {
             string  str  =  ss[i].Trim();
             if (str  ==   "" )  continue ;
            sb1.Append( string .Format( " AND [{0}]=@{1}  " , str, str));
            parameters.Add( new  SqlParameter( " @ "   +  str, values[i]));
        }
         if  (sort.Trim()  !=   "" ) sb1.Append( "  order by  "   +  sort.Trim());
        SqlCommand command  =   new  SqlCommand(sb1.ToString());
         foreach  (SqlParameter p  in  parameters)
        {
            command.Parameters.Add(p);
        }
        DataSet ds  =  ExecuteDataSet(command);
         if  (ds  !=   null   &&  ds.Tables.Count  >   0 )
             return  ds.Tables[ 0 ];
         else
             return   null ;
    }

     ///   <summary>
     ///  修改
     ///   </summary>
     ///   <param name="table"></param>
     ///   <param name="key"></param>
     ///   <param name="row"></param>
     ///   <returns></returns>
     public   int  Update( string  table,  string  key, DataRow row)
    {
        key  =  key.ToLower();
        StringBuilder sb1  =   new  StringBuilder();
        StringBuilder sb2  =   new  StringBuilder();
         string  head  =   string .Format( " UPDATE [{0}] SET  " , table);
        sb1.Append(head);
        ArrayList parameters  =   new  ArrayList();
         foreach  (DataColumn dc  in  row.Table.Columns)
        {
             string  name  =  dc.ColumnName.ToLower();
             if  (row[name]  !=  DBNull.Value)
            {
                 if  (key.IndexOf(name)  !=   - 1 )
                {
                     if  (sb2.Length  ==   0 )
                    {
                        sb2.Append( "  WHERE [ "   +  name  +   " ] = @ "   +  name);
                    }
                     else
                    {
                        sb2.Append( "  AND [ "   +  name  +   " ] = @ "   +  name);
                    }
                }
                 else
                {
                     if  (sb1.ToString()  ==  head)
                    {
                        sb1.Append( " [ "   +  name  +   " ] =  "   +   " @ "   +  name);
                    }
                     else
                    {
                        sb1.Append( " , [ "   +  name  +   " ] =  "   +   " @ "   +  name);
                    }
                }
                SqlParameter param  =   new  SqlParameter( " @ "   +  name, row[name]);
                parameters.Add(param);
            }
        }

        sb1.Append(sb2.ToString());
        SqlCommand command  =   new  SqlCommand(sb1.ToString());
         foreach  (SqlParameter p  in  parameters)
        {
            command.Parameters.Add(p);
        }
         return  ExecuteNonQuery(command);
    }

     ///   <summary>
     ///  删除
     ///   </summary>
     ///   <param name="table"></param>
     ///   <param name="key"></param>
     ///   <param name="values"></param>
     ///   <returns></returns>
     public   int  Delete( string  table,  string  key,  object [] values)
    {
        key  =  key.ToLower();
        StringBuilder sb1  =   new  StringBuilder();
        StringBuilder sb2  =   new  StringBuilder();
         string  head  =   string .Format( " DELETE FROM {0} WHERE 1=1  " , table);
        sb1.Append(head);
        ArrayList parameters  =   new  ArrayList();
         string [] ss  =  key.Split( ' , ' );
         for ( int  i  = 0 ; i  <  ss.Length; i  ++ )
        {
             string  str  =  ss[i].Trim();
             if (str  ==   "" )  continue ;
            sb2.Append( string .Format( " AND [{0}]=@{1}  " , str, str));
            parameters.Add( new  SqlParameter( " @ "   +  str, values[i]));
        }
         if  (sb2.Length  ==   0 )  return   0 ;
        SqlCommand command  =   new  SqlCommand(sb1.Append(sb2.ToString()).ToString());
         foreach  (SqlParameter p  in  parameters)
        {
            command.Parameters.Add(p);
        }
         return  ExecuteNonQuery(command);
    }

     #endregion

     #region  Transaction

     ///   <summary>
     ///  Begin transaction
     ///   </summary>
     public   void  BeginTransaction()
    {
        SqlConnection connection  =  Connection;
         if  (connection.State  ==  ConnectionState.Closed)
        {
            connection.Open();
        }

        SqlTransaction transaction  =  Transaction;
         if  (transaction  ==   null )
        {
            transaction  =  connection.BeginTransaction();
        }

        Connection  =  connection;
        Transaction  =  transaction;
    }

     ///   <summary>
     ///  Commit transaction
     ///   </summary>
     public   void  Commit()
    {
        SqlConnection connection  =  Connection;
        SqlTransaction transaction  =  Transaction;
         if  (transaction  !=   null )
        {
            transaction.Commit();
            transaction.Dispose();
            transaction  =   null ;
            Transaction  =   null ;
             if  (connection.State  ==  ConnectionState.Open)
            {
                connection.Close();
            }
        }
    }

     ///   <summary>
     ///  Rollback transaction
     ///   </summary>
     public   void  Rollback()
    {
        SqlConnection connection  =  Connection;
        SqlTransaction transaction  =  Transaction;
         if  (transaction  !=   null )
        {
            transaction.Rollback();
            transaction.Dispose();
            transaction  =   null ;
            Transaction  =   null ;
             if  (connection.State  ==  ConnectionState.Open)
            {
                connection.Close();
            }
        }
    }

     #endregion
}

转载于:https://www.cnblogs.com/angushine/archive/2008/12/06/1348885.html

weixin_30687587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#通用数据库访问类 常用6种数据库VS2008
06-27
通用数据库访问类 通过配置 可实现不同数据库的的访问&def目前实现了SQLserver&def Oracle&def DataAccess <!----> <!----> <!----> <!----> 调用: IDBOperator idb = DBOperator.GetInstance(); string sqlAccess = @"SELECT * FROM Orders"; DataTable dt = idb.ReturnDataTable(sqlAccess);
asp.net 通用数据访问类
10-06
在ASP.NET开发中，创建一个通用数据访问类是提高代码复用性和降低维护成本的重要实践。这个类通常封装了数据库连接、SQL语句执行、事务处理等基础操作，使得业务逻辑层无需直接与数据库交互，从而实现解耦。以下是...
通用数据库访问类
江湖之远
04-17 1491
/********************************************************************************************************* 名称空间:DataBase 模块名称:DAO.cs 类库介绍:实现独立于数库的的DAO类,支持SQL数据提供者|OLEDB数据提供者|ODBC数据提供者          数据库配置信息
数据访问通用类（C#）
hi_dzj的专栏
11-29 784
using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Data; using System.Data.SqlClient; using System.Configuration; namespace SqlHelper { public class
c#(二十九) —— 通用数据库访问类
java能飞翔
12-16 986
如果项目里需要经常访问数据库，并且使用增删改查等方法，为了方便开发，可使用通用数据库访问类 此处需注意两个事情， 一是为了提高性能，将SQLHelper里的方法均设为static。 二是由于需要在测试类进行读取数据，因此不能在读取数据集方法resultSetQuery()内关闭连接，因此采用System.Data.CommandBehavior.CloseConnection这一枚举变量的方法。 通用数据库访问类 SQLHelper using System.Data.SqlClient; namespa
共享一个通用的数据访问类
johncools的博客
07-04 1011
在WEB项目开发中,免不了常常要写一堆的数据访问的重复代码,呵呵,不过这个在学生时代可能会经常发生.但在实际生产开发环境中,要么用DAAB,要么自己动手写一个.其实很多时候都是用DAAB :),不过有时候还是觉得自己写的用着舒服点,毕竟那个DAAB也太庞大了!代码如下:[在开发的时候可以直接Copy使用]:using System;using System.Data;using System.
ASP.NET对SQLServer的通用数据库访问类
10-22
ASP.NET中的`SqlHelper`类是一个通用的数据库访问组件，设计用于简化与SQL Server数据库的交互。这个类封装了常见的数据库操作，如执行查询、存储过程等，使得开发者无需在每次需要与数据库通信时都重复编写相同的...
ADO.NET通用数据库访问类
10-22
ADO.NET通用数据库访问类是开发者为了简化数据库操作而设计的抽象层，它封装了基本的数据库连接、命令执行、数据读取等功能，使得在不同数据库间切换时无需大量修改代码。 在给定的代码示例中，我们看到一个名为`...
c#.net 通用的数据访问类
03-25
c#写的数据访问类 /// /// 通用数据库访问类－UniversalDAL类， /// 支持SqlClient、OleDb、Odbc、OracleClient等 /// 不同类型的数据源
C#学习笔记---通用数据访问类的编写（不带参数）
最新发布
xhtom44301的博客
01-11 201
通用数据访问类的编写（不带参数）
C#通用数据访问类库
liuyaokai1990的博客
05-22 184
说明：此篇文章是给那些和我一样仍在使用ADO.NET访问数据库的.NET开发人员写的，因为某些原因，比如还在使用.NET3.0以下版本开发.NET应用或者所使用的数据库对ORM支持不是很好，或者是对ORM的性能有所怀疑(其实在访问量不是很大的情况下没有必要过分追求性能的极限)等等，这部分人仍在使用传统的ADO.NET来访问数据库，他们或手写或采用代码生成工具来生成实体类和增删改查的SQL...
.NET通用的数据库操作类(支持多种数据库)
记得微笑的专栏
05-13 8775
通用的数据库操作类(支持多种数据库)       我们在软件开发过程中,数据库是一个永久不变的话题,但是根据软件架构与客户要求的不同我们会选择不同的数据库,在C#中不同数据库操作编写代码不尽相同,下面提供一种通用的数据库操作方案,只需要根据config的配置就可以动态的选择不同的数据库. 在配置文件中providerName指定不同的数据库类型.           
何时用ExecuteDataSet / ExecuteReader() / ExecuteScalar
热门推荐
single_killer的专栏
01-14 1万+
1、ExecuteDatasetExecuteDataset会运行你的基本SELECT（选择）查询并生成一个DataSet，然后就能够被绑定到服务器对象上，或者被用来创建DataView(数据视图）。public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdTex
关于DataSet事务处理以及SqlDataAdapter四种用法
linuxstuding
10-28 202
如果是直接执行SQL语句时，事务很好处理，对于大多数的Erp应用，不能能用SQL来处理数据，所以更新DataSet更为常用，更新单个的DataSet也非常简单，不需要事务的处理，给多个DataSet增加事务多数应用于分布式的程序代码中，下面为在Webservice中更新Winform传递过来的经过压缩的数据集的事务处理代码，多个DataSet 情况。 /// &lt;summary&gt; ...
C# 数据库访问通用类 (ADO.NET)
CoffeMilk的博客
02-11 932
注意：本内容来自： https://www.oschina.net/code/snippet_12_1317 [1].[代码] SqlDbHelper.cs using System; using System.Collections.Generic; using System.Text; using System.Data; using System.Data.SqlClient; usi...
使用设计模式构建通用数据库访问类
sunny_y_m的专栏
05-17 1732
使用设计模式构建通用数据库访问类作者：孙亚民    本文选自：赛迪网  2003年03月20日 　　在应用程序的设计中，数据库的访问是非常重要的，我们通常需要将对数据库的访问集中起来，以保证良好的封装性和可维护性。在.Net中，数据库的访问，对于微软自家的SqlServer和其他数据库（支持OleDb），采用不同的访问方法，这些类分别分布于System.Data.SqlCl
大规模集群中的高效通用数据处理框架
首先，它强调了分布式存储系统的重要性，这类系统能够容错并提供高吞吐量的数据访问。例如，Hadoop的HDFS（Hadoop Distributed File System）就是一个典型的例子，它为大规模数据处理提供了基础。 其次，报告讨论了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值