数据访问层

在应用程序的设计中，数据库的访问是非常重要的，我们通常需要将对数据库的访问集中起来，以保证良好的封装性和可维护性。在.Net中，数据库的访问，对于微软自家的SqlServer和其他数据库（支持OleDb），采用不同的访问方法，这些类分别分布于System.Data.SqlClient和System.Data.OleDb名称空间中。微软后来又推出了专门用于访问Oracle数据库的类库。我们希望在编写应用系统的时候，不因这么多类的不同而受到影响，能够尽量做到数据库无关，当后台数据库发生变更的时候，不需要更改客户端的代码。
　　有的时候，为了性能和其他原因，我们也希望提供对数据库访问的缓存，特别是数据库连接的缓存。虽然微软给我们内置了数据库缓存，但是，自己控制缓存，无疑可以提供更大的灵活性和效率。

public class BaseDataAccess : IDisposable
{
/// 数据适配器
private SqlDataAdapter dsAdapter;
/// 数据更新事务句柄
SqlTransaction dsTransaction;
private SqlCommand selectCommand;
private SqlCommand updateCommand;
private SqlCommand insertCommand;
private SqlCommand deleteCommand;
// 数据库连接
private SqlConnection dbConnection;
private DBConfigration dbConfigration = new DBConfigration();
public BaseDataAccess()
{
/// 创建数据适配器对象“OldDbDataAdapter”
dsAdapter = new SqlDataAdapter();
/// 获取数据操纵连接
dbConnection = new SqlConnection(DBConfigration.BitSoftConnectionString);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
protected virtual void Dispose(bool disposing)
{
if (! disposing)
return;
if (dsAdapter != null )
{
if (dsAdapter.SelectCommand != null)
{
if( dsAdapter.SelectCommand.Connection != null)
dsAdapter.SelectCommand.Connection.Dispose();
dsAdapter.SelectCommand.Dispose();
}
dsAdapter.Dispose();
dsAdapter = null;
}
}
///
/// 检查传入的单个数据表单（DataTable）字段域,自动获得该数据表单的“Update”命令。
///
/// 单个数据表单
/// SqlCommand
private SqlCommand GetUpdateByIdCommand(DataTable oneTable)
{
string sqlFirst = " UPDATE “;
string sqlSecond = " WHERE “;
sqlFirst = sqlFirst + oneTable.TableName + " SET “;
/// 创建 SqlCommand 对象
if ( updateCommand == null )
{
updateCommand = new SqlCommand(sqlFirst, dbConnection);
}
/// Update 语句的参数表集合
SqlParameterCollection updateParams = updateCommand.Parameters;
updateCommand.Parameters.Clear();
/// 遍历 DataTable 字段，生成 SQL UPDATE 语句
bool isFirstColumn = true;
bool isFirstKeyColumn = true;
foreach (BaseDataColumn dc in oneTable.Columns)
{
/// 忽略无用字段
if ( dc.IsValidColumn() )
{
/// 获取关键字字段
if ( dc.IsKeyColumn() )
{
if ( isFirstKeyColumn )
{
sqlSecond = sqlSecond + dc.ColumnName + " = @”+dc.ColumnName;
isFirstKeyColumn = false;
}
else
sqlSecond = sqlSecond + " AND " + dc.ColumnName + " = @”+dc.ColumnName;
}
else
{
if ( isFirstColumn )
{
sqlFirst = sqlFirst + dc.ColumnName + " = @”+dc.ColumnName;
isFirstColumn = false;
}
else
sqlFirst = sqlFirst + “, " + dc.ColumnName + " = @”+dc.ColumnName;
updateParams.Add(new sqlParameter("@"+dc.ColumnName,dc.GetColumnSqlDbType()));
updateParams["@"+dc.ColumnName].SourceColumn = dc.ColumnName;
}
}
}
foreach (BaseDataColumn dc in oneTable.Columns)
{
/// 忽略无用字段
if ( dc.IsValidColumn() )
{
/// 获取关键字字段
if ( dc.IsKeyColumn() )
{
updateParams.Add(new SqlParameter("@"+dc.ColumnName, dc.GetColumnSqlDbType()));
updateParams["@"+dc.ColumnName].SourceColumn = dc.ColumnName;
}
}
}
/// 设置 Command 类型和完整的 UPDATE 语句
updateCommand.CommandType = CommandType.Text;
updateCommand.CommandText = sqlFirst + sqlSecond;
return updateCommand;
}
///
/// 检查传入的单个数据表单（DataTable）字段域,自动获得该数据表单的“Insert”命令。
///
/// 单个数据表单
/// SqlCommand
private SqlCommand GetInsertCommand(DataTable oneTable)
{
string sqlFirst = " INSERT INTO “;
string sqlSecond = " VALUES ( “;
/// 拼接表名
sqlFirst = sqlFirst + oneTable.TableName ;
/// 创建 SqlCommand 对象
if ( insertCommand == null )
{
insertCommand = new SqlCommand(sqlFirst, dbConnection);
}
/// Insert 语句的参数表集合
SqlParameterCollection insertParams = insertCommand.Parameters;
insertCommand.Parameters.Clear();
/// 遍历 DataTable 字段，生成 SQL INSERT 语句
bool isFirstColumn = true;
foreach (BaseDataColumn dc in oneTable.Columns)
{
/// 忽略无用字段
if ( dc.IsValidColumn() && !dc.AutoIncrement)
{
if ( isFirstColumn )
{
sqlFirst = sqlFirst + " (” + dc.ColumnName;
isFirstColumn = false;
sqlSecond = sqlSecond +”@"+dc.ColumnName;
}
else
{
sqlFirst = sqlFirst + “, " + dc.ColumnName;
sqlSecond = sqlSecond + “,” +”@"+dc.ColumnName;
}

 /// 生成 Insert 参数表集合
 insertParams.Add(new SqlParameter("@"+dc.ColumnName, dc.GetColumnSqlDbType()));
 insertParams["@"+dc.ColumnName].SourceColumn = dc.ColumnName;
}

}
/// 设置 Command 类型和完整的 UPDATE 语句
insertCommand.CommandType = CommandType.Text;
insertCommand.CommandText = sqlFirst + “) " + sqlSecond + " )”;
return insertCommand;
}
///
/// 检查传入的单个数据表单（DataTable）字段域,自动获得该数据表单的“Delete”命令。
///
/// 单个数据表单
/// SqlCommand
private SqlCommand GetDeleteByIdCommand(DataTable oneTable)
{
string sqlFirst = " DELETE FROM “;
sqlFirst = sqlFirst + oneTable.TableName + " WHERE “;
/// 创建 SqlCommand 对象
if ( deleteCommand == null )
{
deleteCommand = new SqlCommand(sqlFirst, dbConnection);
}
/// Delete 语句的参数表集合
SqlParameterCollection deleteParams = deleteCommand.Parameters;
deleteCommand.Parameters.Clear();
/// 遍历 DataTable 字段，生成 SQL DELETE 语句
bool isFirstKeyColumn = true;
foreach (BaseDataColumn dc in oneTable.Columns)
{
/// 忽略无用字段
if ( dc.IsValidColumn() )
{
/// 获取关键字字段
if ( dc.IsKeyColumn() )
{
if ( isFirstKeyColumn )
{
sqlFirst = sqlFirst + dc.ColumnName + " = @”+dc.ColumnName;
isFirstKeyColumn = false;
}
else
sqlFirst = sqlFirst + " AND " + dc.ColumnName + " = @”+dc.ColumnName;

  /// 生成 Delete 参数表集合
  deleteParams.Add(new SqlParameter("@"+dc.ColumnName, dc.GetColumnSqlDbType()));
  deleteParams["@"+dc.ColumnName].SourceColumn = dc.ColumnName;
 }
}

}
/// 设置 Command 类型和完整的 DELETE 语句
deleteCommand.CommandType = CommandType.Text;
deleteCommand.CommandText = sqlFirst;
return deleteCommand;
}

///
/// 根据指定的对象数据集，更新相应的数据库。
///
/// 对象数据集
/// 返回是否成功的布尔值
public bool UpdateObjectData(BaseDataSet myDataSet)
{
if ( dsAdapter == null )
{
throw new System.ObjectDisposedException( GetType().FullName );
}
try
{
dbConnection.Open();
try
{
dsTransaction = dbConnection.BeginTransaction();
}
catch
{
dbConnection.Close();
return false;
}
/// 遍历 DataSet 中的每一个表单进行更新处理
foreach (DataTable dt in myDataSet.Tables)
{
dsAdapter.UpdateCommand = GetUpdateByIdCommand(dt);
/// 设置记录更新的事务句柄
dsAdapter.UpdateCommand.Transaction = dsTransaction;
/// 根据传入DataSet的表和表中的内容更新相应的数据库
dsAdapter.Update( myDataSet, dt.TableName);
}
try
{
dsTransaction.Commit();
}
catch
{
dsTransaction.Rollback();
return false;
}
finally
{
/// 无论更新是否成功，及时释放数据库连接
dbConnection.Close();
}
/// 刷新 DataSet 更新标志
myDataSet.AcceptChanges();
return true;
}
catch(Exception e)
{
string a=e.Message;
return false;
}
}
///
/// 根据指定的对象数据集，新增插入相应的数据库。
///
/// 对象数据集
/// 返回是否成功的布尔值
public bool InsertObjectData(BaseDataSet myDataSet)
{
if ( dsAdapter == null )
{
throw new System.ObjectDisposedException( GetType().FullName );
}
try
{
dbConnection.Open();
/// 启动事务处理
try
{
dsTransaction = dbConnection.BeginTransaction();
}
catch
{
dbConnection.Close();
return false;
}
/// 遍历 DataSet 中的每一个表单进行更新处理
try
{
/// 调用自动产生关键字ID的方法。
if ( AutoCreatID(myDataSet,dsTransaction) )
{
foreach (DataTable dt in myDataSet.Tables)
{
dsAdapter.InsertCommand = GetInsertCommand(dt);
/// 设置记录更新的事务句柄
dsAdapter.InsertCommand.Transaction = dsTransaction;
/// 根据传入DataSet的表和表中的内容更新相应的数据库
dsAdapter.Update( myDataSet, dt.TableName);
}
/// 提交事务
dsTransaction.Commit();
}
else
{
/// 回滚事务
dsTransaction.Rollback();
return false;
}
}
catch(Exception e)
{
/// 回滚事务
string a=e.Message;
dsTransaction.Rollback();
return false;
}
finally
{
/// 无论更新是否成功，及时释放数据库连接
dbConnection.Close();
}
/// 刷新 DataSet 更新标志
myDataSet.AcceptChanges();
return true;
}
catch(Exception e)
{
string a=e.Message;
return false;
}
}
///
/// 根据指定的对象数据集，删除相应的数据库记录。
///
/// 对象数据集
/// 返回是否成功的布尔值
public bool DeleteObjectData(BaseDataSet myDataSet)
{
if ( dsAdapter == null )
{
throw new System.ObjectDisposedException( GetType().FullName );
}
try
{
dbConnection.Open();
try
{
dsTransaction = dbConnection.BeginTransaction();
}
catch
{
dbConnection.Close();
return false;
}
/// 遍历 DataSet 中的每一个表单进行更新处理
try
{
foreach (DataTable dt in myDataSet.Tables)
{
dsAdapter.DeleteCommand = GetDeleteByIdCommand(dt);
/// 设置记录更新的事务句柄
dsAdapter.DeleteCommand.Transaction = dsTransaction;
/// 根据传入DataSet的表和表中的内容更新相应的数据库
dsAdapter.Update( myDataSet, dt.TableName);
}
dsTransaction.Commit();
}
catch(Exception e)
{
string a=e.Message;
dsTransaction.Rollback();
return false;
}
finally
{
/// 无论更新是否成功，及时释放数据库连接
dbConnection.Close();
}
/// 刷新 DataSet 更新标志
myDataSet.AcceptChanges();
return true;
}
catch
{
return false;
}
}
///
/// 根据指定的对象数据集，同时删除、修改、添加相应的数据库记录。
///
/// 对象数据集
/// 返回是否成功的布尔值
public bool SynchronizeObjectData(BaseDataSet dataSet)
{
if ( dsAdapter == null )
{
throw new System.ObjectDisposedException( GetType().FullName );
}
try
{
dbConnection.Open();
try
{
dsTransaction = dbConnection.BeginTransaction();
}
catch
{
dbConnection.Close();
return false;
}
/// 遍历 DataSet 中的每一个表单进行更新处理
try
{
/// 调用自动产生关键字ID的方法。
if ( AutoCreatID(dataSet,dsTransaction) )
{
foreach (DataTable dt in dataSet.Tables)
{
/// 删除相应记录。
dsAdapter.DeleteCommand = GetDeleteByIdCommand(dt);
/// 设置记录删除的事务句柄
dsAdapter.DeleteCommand.Transaction = dsTransaction;
/// 修改相应记录。
dsAdapter.UpdateCommand = GetUpdateByIdCommand(dt);
/// 设置记录更新的事务句柄
dsAdapter.UpdateCommand.Transaction = dsTransaction;
/// 新增相应记录。
dsAdapter.InsertCommand = GetInsertCommand(dt);
/// 设置记录更新的事务句柄
dsAdapter.InsertCommand.Transaction = dsTransaction;
/// 根据传入DataSet的表和表中的内容删除/更新/新增相应的数据库
dsAdapter.Update( dataSet, dt.TableName);
}
/// 提交事务
dsTransaction.Commit();
}
else
{
/// 回滚事务
dsTransaction.Rollback();
return false;
}
}
catch
{
dsTransaction.Rollback();
return false;
}
finally
{
/// 无论更新是否成功，及时释放数据库连接
dbConnection.Close();
}
/// 刷新 DataSet 更新标志
dataSet.AcceptChanges();
return true;
}
catch
{
return false;
}
}

///
/// 根据传入关键字值列表，填充相应的对象数据集。
/// 注意：关键字值列表为“@字段名，关键字值”格式的参数表。
///
/// 用于装配的数据集对象
/// 对象的关键字（可能多个）和值参数表
/// 返回是否成功的布尔值
public BaseDataSet FillDataSetByArray(BaseDataSet dataSet, ParmArrayWithOP keyArray)
{
if ( dsAdapter == null )
{
throw new System.ObjectDisposedException( GetType().FullName );
}
try
{
foreach (DataTable dt in dataSet.Tables)
{
dsAdapter.SelectCommand = GetSelectBySqlOP(dt,keyArray);
// 设置关键字的值
foreach (SqlParameter pt in dsAdapter.SelectCommand.Parameters)
{
dsAdapter.SelectCommand.Parameters[pt.ParameterName].Value = keyArray.GetParmValue(keyArray.IndexOf(pt.ParameterName));
}
dsAdapter.Fill(dataSet,dt.TableName);
}
}
catch
{
/// 写入例外处理错误消息。
//MessagerBulletin.WriteMsg(e.Message);
return dataSet;
}
return dataSet;
}
///
///说明：该方法将取得带有分页显示功能的SELECT语句。目的是一次只返回一页的记录，而不是整个表记录。
/// 该方法有两种重载形式，分别为为带条件的查询和不带条件的查询。
///参数： intPageNum：每页的显示的记录数
/// intPageIndex：当前页号
/// strTableName：表名
/// strKey"：主键
/// strParam[]：参数数组。此值仅当blnCondition为true时有效。
/// objValues[]：值数组。此值仅当blnCondition为ture时有效。
/// strOrderField：排序的字段名
/// strOrderType：排序类型，是升序还是降序。其值为：ASC-升序，DESC-降序
///返回：select语句，其中输出参数返回取得记录总数的SQL语句，方法本身返回查询SQL语句
///

public string GetPageSelectByID(int intPageNum,int intPageIndex,string strTableName,string strKey,string[] strParams,object[] objValues,string strOrderField,string strOrderType,out string strSqlCount)
{
string strSql;
string strTemp = " "; //存放条件字句

//构造select语句
strSql = "select Top " + intPageNum.ToString() + " * from " + strTableName + " where "
+ strKey + " not in (select top " + ((intPageIndex - 1) * intPageNum).ToString() + " " + strKey + " from " + strTableName;

//在生成的select语句上加上where条件子句
if ((strParams.Length == 0) | (strParams.Length != objValues.Length))
{
throw (new ParamValueNotMatchException(“缺少参数值或参数与值不对应”));
}
for (int i=0;i <= strParams.Length - 1;i++)
{
strTemp = strTemp + " and " + strParams[i] + “=” + “’” + objValues[i].ToString() + “’”;
}
char[] and = new char[] {‘a’,‘n’,‘d’};
strTemp = (strTemp.TrimStart()).TrimStart(and); //去除头部多余的"and"
strSql = strSql + " where " + strTemp + " order by " + strOrderField + " " + strOrderType + “)”
+ " and " + strTemp + " order by " + strOrderField + " " + strOrderType ;
//得到查询总记录数的语句
strSqlCount = "select count(*) from " + strTableName + " where " + strTemp;
return strSql;
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=526545

Feedback
#1楼回复引用查看
2006-05-02 18:21 by 天轰穿
收藏了,很好,返回来感谢,呵呵!!我现在正在猛学数据存储方面知识!!
#2楼回复引用查看
2006-05-03 00:14 by 老新
//数据访问层，网上找的。

扫描二维码关注公众号，回复： 8972819 查看本文章

using System;
using System.Data;
using System.Data.SqlClient;

namespace EmploymentCentre.component
{
///
/// 存储过程的参数的类型，在输出型的参数里使用。
///
public enum ParameterKind
{
Int,Double,Decimal,NVarChar,Bit
}
///
/// 这是一个通用的数据访问层接口。类似于 SQLHelper
///
public sealed class DataAccessLayer
{

#region 属性
private static string errorMsg; //出错信息
private static bool isShowErrorSQL; //是否显示出错的查询语句（包括存储过程名程）
private int executeRowCount; //获取执行SQL查询语句后影响的行数
private SqlCommand cm = new SqlCommand(); //建立Command对象
private SqlTransaction sqlTrans ; //用于事务处理
private bool isUseTrans; //是否启用了 .net 的事务处理
///
/// 读取出错信息
///
public string ErrorMsg
{
get{return errorMsg;}
}
///
/// 修改连接字符串，在同时访问两个或两个以上的数据库的时候使用
///
public string cnString
{
set{cm.Connection.ConnectionString = value;}
get{return cm.Connection.ConnectionString;}
}
///
/// 获取执行SQL查询语句后影响的行数
///
public int ExecuteRowCount
{
get{return executeRowCount;}
}
///
/// 释放资源
///
public void Dispose()
{
if (isUseTrans)
sqlTrans.Dispose();

errorMsg = null;
cm.Parameters.Clear();
cm.Connection.Dispose();
cm.Dispose();
}
#endregion
public DataAccessLayer() //构造函数
{
//默认不使用事务
isUseTrans = false;
//获取连接字符串
cm.Connection = new SqlConnection(System.Configuration.ConfigurationSettings.AppSettings[“ConnectionString”]);
//初始化错误信息
errorMsg=“0”;
isShowErrorSQL = true; //本地运行，显示出错的查询语句（包括存储过程名程）
//isShowErrorSQL = false; //服务器运行，不显示出错的查询语句（包括存储过程名程）
}

#region 内部函数
//添加Image、Text、NText 型的参数时不指定大小
private void addParameter(string ParameterName,SqlDbType sqlType,int size)
{
switch(sqlType)
{
case SqlDbType.Image:
goto case SqlDbType.NText;
case SqlDbType.Text:
goto case SqlDbType.NText;
case SqlDbType.NText:
cm.Parameters.Add(ParameterName,sqlType); //添加存储过程的参数
break;
default:
cm.Parameters.Add(ParameterName,sqlType,size); //添加存储过程的参数
break;
}
}
#endregion
#region 记录错误日志
//如果要使用的话，根据你的需要进行修改。
public void addLogErr(string SPName,string ErrDescribe)
{
//记录到错误日志
//暂时这样，以后从session中取
//帐套ID ＝1
//操作工号＝’admin’
//操作模块=存储过程名
//错误号＝0
//解决标志：0否1是＝0*/
// SqlCommand cmErr = new SqlCommand();
// cmErr.Connection = new SqlConnection(EmploymentCentre.component.Connection.ConnectionString());
// cmErr.CommandType = CommandType.StoredProcedure;
// cmErr.CommandText = “Proc_common_logErrs_add” ;
// cmErr.Parameters.Add("@in_accountID" ,SqlDbType.Int ); //0
// cmErr.Parameters.Add("@in_chName" ,SqlDbType.NVarChar ,16); //1
// cmErr.Parameters.Add("@in_SubFunc" ,SqlDbType.NVarChar ,80); //2
// cmErr.Parameters.Add("@in_ErrDescribe" ,SqlDbType.NVarChar ,300); //3
// cmErr.Parameters.Add("@in_ErrNumber" ,SqlDbType.Int ); //4
// cmErr.Parameters.Add("@in_comFlag" ,SqlDbType.Int ); //5
// cmErr.Parameters.Add("@ReturnMsg" ,SqlDbType.NVarChar ,60); //6
// cmErr.Parameters.Add("@ReturnStatus" ,SqlDbType.NVarChar ,4) ; //7
//
// cmErr.Parameters[0].Value = 1; //帐套ID ＝1
// cmErr.Parameters[1].Value = “admin”;//操作工号＝’admin’
// cmErr.Parameters[2].Value = SPName; //操作模块=存储过程名
// cmErr.Parameters[3].Value = ErrDescribe;
// cmErr.Parameters[4].Value = 0; //错误号＝0
// cmErr.Parameters[5].Value = 0; //解决标志：0否1是＝0*/
// cmErr.Parameters[6].Direction = ParameterDirection.Output;
// cmErr.Parameters[7].Direction = ParameterDirection.Output;
// try
// {
// cmErr.Connection.Open();
// cmErr.ExecuteNonQuery();
// cmErr.Connection.Close();
// }
// catch(Exception ex)
// {
// errorMsg = ex.Message;
// }
// finally
// {
// cmErr.Parameters.Clear();
// cmErr.Connection.Close();
// cmErr.Dispose();
// }

}
#endregion

#region 存储过程的参数部分——清除和添加参数
#region 以前写的，不建议使用了。
///
/// 添加存储过程的参数，方向为输出。不建议使用这种方法，因为如果更换数据库的时候SqlDbType参数会比较麻烦。
///
/// 参数名称。比如 @UserName
/// 参数值
/// 参数类型
/// 参数大小
/// 随意写个整数就行，为了区分函数重载
public void addNewParameter(string ParameterName,string ParameterValue,SqlDbType sqlType,int size,int Direction)
{
//添加存储过程的参数
addParameter(ParameterName,sqlType,size);
cm.Parameters[ParameterName].Value=ParameterValue; //负值
cm.Parameters[ParameterName].Direction=ParameterDirection.Output; //设置方向为输出
}
///
/// 添加存储过程的参数，方向为输入（input）。不建议使用这种方法，因为如果更换数据库的时候SqlDbType参数会比较麻烦。
///
/// 参数名称。比如 @UserName
/// 参数值
/// 参数类型
/// 参数大小
public void addNewParameter(string ParameterName,string ParameterValue,SqlDbType sqlType,int size)
{
//添加存储过程的参数
addParameter(ParameterName,sqlType,size);
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion
#region 清除参数
///
/// 清除SqlCommand的存储过程的参数。
///
public void ClearParameter()
{cm.Parameters.Clear();}
#endregion

#region 输入型的参数 int 、double、decimal、nvarChar、nText,bit,char、datetime、
#region int
///
/// 添加int型的参数。
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,int ParameterValue)
{
cm.Parameters.Add(ParameterName,SqlDbType.Int,4); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
//设置方向取默认值——输入
}
#endregion

#region double
///
/// 添加小数参数，double
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,double ParameterValue )
{
cm.Parameters.Add(ParameterName,SqlDbType.Float ); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region decimal
///
/// 添加小数参数，方向是输入（input）。decimal
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,decimal ParameterValue )
{
cm.Parameters.Add(ParameterName,SqlDbType.Decimal); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region nvarChar
///
/// 添加nvarChar型的参数。方向是输入（input）
///
/// 参数名称。比如 @UserName
/// 参数值
/// 参数大小
public void addNewParameter(string ParameterName,string ParameterValue,int size)
{
cm.Parameters.Add(ParameterName,SqlDbType.NVarChar,size); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region nText
///
/// 添加nText型的参数。方向是输入（input）
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,string ParameterValue)
{
cm.Parameters.Add(ParameterName,SqlDbType.NText); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region bit
///
/// 添加bit型的参数。方向是输入（input）
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,bool ParameterValue)
{
cm.Parameters.Add(ParameterName,SqlDbType.Bit); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region DateTime
///
/// 添加DateTime型的参数．方向是输入(input)
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,System.DateTime ParameterValue)
{
cm.Parameters.Add(ParameterName,SqlDbType.DateTime); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#region char
///
/// 添加char型的参数．方向是输入(input)
///
/// 参数名称。比如 @UserName
/// 参数值
public void addNewParameter(string ParameterName,char ParameterValue)
{
cm.Parameters.Add(ParameterName,SqlDbType.Char,1); //添加存储过程的参数
cm.Parameters[ParameterName].Value=ParameterValue; //负值
}
#endregion

#endregion
#region 输出型的参数

///
/// 添加输出型的参数。只支持常用的几个参数类型，如果需要可以扩充。
///
/// 参数名称。比如 @UserName
/// 参数的类型
public void addNewParameter(string ParameterName,EmploymentCentre.component.ParameterKind kind)
{
switch(kind)
{
case ParameterKind.Int :
cm.Parameters.Add(ParameterName,SqlDbType.Int); //添加存储过程的参数
break;
case ParameterKind.Double:
cm.Parameters.Add(ParameterName,SqlDbType.Float); //添加存储过程的参数
break;
case ParameterKind.Decimal :
cm.Parameters.Add(ParameterName,SqlDbType.Decimal); //添加存储过程的参数
break;
case ParameterKind.NVarChar :
cm.Parameters.Add(ParameterName,SqlDbType.NVarChar,4000); //添加存储过程的参数
break;
case ParameterKind.Bit :
cm.Parameters.Add(ParameterName,SqlDbType.Bit); //添加存储过程的参数
break;
}
cm.Parameters[ParameterName].Direction= ParameterDirection.Output; //设置方向
}

///
/// 添加nvarChar型的参数。方向是输出（output）
///
/// 参数名称。比如 @UserName
public void addNewParameter(string ParameterName)
{
//比较常用，所以又写了一个
cm.Parameters.Add(ParameterName,SqlDbType.NVarChar ,4000); //添加存储过程的参数
cm.Parameters[ParameterName].Direction = ParameterDirection.Output; //设置方向
}

#endregion
#endregion
#region 存储过程的参数部分——取参数的返回值
///
/// 按序号返回参数值，一般在执行完存储过程后使用
///
/// 序号
/// 返回参数的内容
public string getParameter(int ParameterIndex)
{
return cm.Parameters[ParameterIndex].Value.ToString();
}
///
/// 按名称返回参数值，一般在执行完存储过程后使用
///
/// 参数名称。比如 @UserName
/// 返回参数的内容
public string getParameter(string ParameterName)
{
return cm.Parameters[ParameterName].Value.ToString();
}
#endregion
#region 存储过程的参数部分——修改参数值
///
/// 按序号修改参数值，一般在一次添加多条记录时用。
///
/// 序号
public void setParameter(int ParameterIndex,string parameterValue)
{
cm.Parameters[ParameterIndex].Value = parameterValue;
}
///
/// 按名称修改参数值，一般在一次添加多条记录时用
///
/// 参数名称。比如 @UserName
public void setParameter(string ParameterName,string parameterValue)
{
cm.Parameters[ParameterName].Value = parameterValue;
}
#endregion
#region 事务处理部分。并没有做太多的测试，有不合理的地方请多指教
///
/// 打开连接，并且开始事务。
///
public void TranBegin()
{
cm.Connection.Open();
sqlTrans = cm.Connection.BeginTransaction();
cm.Transaction = sqlTrans;
isUseTrans = true;
}
///
/// 提交事务，并关闭连接
///
public void TranCommit()
{
sqlTrans.Commit();
cm.Connection.Close();
}
///
/// 回滚事务，并关闭连接。在程序出错的时候，自动调用。
///
public void TranRollBack()
{
sqlTrans.Rollback();
cm.Connection.Close();
}
#endregion

#region 运行存储过程返回记录（DataSet、DataTable）
///
/// 运行存储过程返回DataSet。DataSet里面可以是多个表(DateTable)
///
/// 存储过程名称
/// 返回DataSet
#region 函数实现 — — runStoreDataSet
public DataSet runStoreDataSet(string StoredProcedureName)
{
errorMsg = “0”; //清空错误信息
cm.CommandText=StoredProcedureName;
cm.CommandType=CommandType.StoredProcedure;
SqlDataAdapter da = new SqlDataAdapter(cm);
try
{
DataSet DS = new DataSet();
da.Fill(DS);
return DS;
}
catch(Exception ex)
{
errorMsg = “运行runStoreDataSet函数时出现错误。
错误信息：” + ex.Message.Replace("’","");
if (isShowErrorSQL ) errorMsg +=“
存储过程：” + StoredProcedureName;
addLogErr(StoredProcedureName,errorMsg);
return null;
}
finally
{
if (!isUseTrans) //不使用事务的时候才能关闭连接
cm.Connection.Close();
}
}
#endregion
///
/// 运行存储过程返回DataTable。
///
/// 存储过程名称
/// 返回DataTable
#region 函数实现 — — runStoreDataTable
public DataTable runStoreDataTable(string StoredProcedureName)
{
errorMsg = “0”; //清空错误信息
cm.CommandText = StoredProcedureName;
cm.CommandType = CommandType.StoredProcedure;
SqlDataAdapter da = new SqlDataAdapter(cm);
try
{
DataTable dt = new DataTable();
da.Fill(dt);
return dt;
}
catch(Exception ex)
{
errorMsg = “运行runStoreDataTable函数时出现错误。
错误信息：” + ex.Message.Replace("’","");
if (isShowErrorSQL ) errorMsg +="\n
存储过程：" + StoredProcedureName;
addLogErr(StoredProcedureName,errorMsg);
return null;
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}
#endregion

#endregion
#region 运行存储过程不返回记录集，用于添加、修改、删除等操作
///
/// 运行存储过程不返回记录集，用于添加、修改、删除等操作
///
/// 存储过程名称
///
public void runStore(string StoredProcedureName)
{
errorMsg = “0”; //清空错误信息
cm.CommandType=CommandType.StoredProcedure;
cm.CommandText=StoredProcedureName;
try
{
cm.Connection.Open();
cm.ExecuteNonQuery();
}
catch(Exception ex)
{
errorMsg = “运行runStore函数时出现错误。
错误信息：” + ex.Message.Replace("’","");
if (isShowErrorSQL ) errorMsg +=“
存储过程：” + StoredProcedureName;
addLogErr(StoredProcedureName,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}
#endregion

public object runStoreScalar(string StoredProcedureName)
{
errorMsg = “0”; //清空错误信息

cm.CommandType=CommandType.StoredProcedure;
cm.CommandText=StoredProcedureName;
try
{
cm.Connection.Open();
return cm.ExecuteScalar();
}
catch(Exception ex)
{
errorMsg = “运行runStoreScalar函数时出现错误。
错误信息：” + ex.Message.Replace("’","");
if (isShowErrorSQL ) errorMsg +=“
存储过程：” + StoredProcedureName;
addLogErr(StoredProcedureName,errorMsg);
return null;
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}

#region 运行查询语句返回记录（DataSet、DataTable、IDstring、）

///
/// 运行SQL查询语句返回DataTable。
///
/// 查询语句。比如select * from tableName
/// 返回DataTable
#region 函数实现 — — runSqlDataTable
public DataTable runSqlDataTable(string SQL)
{
errorMsg = “0”; //清空错误信息
cm.CommandText=SQL;
cm.CommandType=CommandType.Text;
SqlDataAdapter da=new SqlDataAdapter(cm);
try
{
DataTable DT=new DataTable();
da.Fill(DT);
return DT;
}
catch(Exception ex)
{
errorMsg = “运行runSqlDataTable函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL ;
addLogErr(SQL,errorMsg);
return null;
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}
#endregion
///
/// 运行SQL查询语句返回DataSet。可以传入多条查询语句，返回多个DataTable
///
/// 查询语句。比如select * from tableName
/// 返回DataSet
#region 函数实现 — — runSqlDataSet
public DataSet runSqlDataSet(string SQL)
{
errorMsg = “0”; //清空错误信息
cm.CommandText=SQL;
cm.CommandType=CommandType.Text;
SqlDataAdapter da=new SqlDataAdapter(cm);
try
{
DataSet DS=new DataSet();
da.Fill(DS);
return DS;
}
catch(Exception ex)
{
errorMsg = “运行runSqlDataSet函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL ;
addLogErr(SQL,errorMsg);
return null;
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}
#endregion

#endregion
#region 运行查询语句不返回记录集（无返回记录、返回一个字段、返回一条记录）
///
/// 运行SQL查询语句，不返回记录集。用于添加、修改、删除等操作
///
/// 查询语句。比如insert into tableName 、update tableName…
///
#region 函数实现 — — runSql
public void runSql(string SQL)
{
errorMsg = “0”;
executeRowCount = 0;
cm.CommandText=SQL;
cm.CommandType=CommandType.Text;
try
{
if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
cm.Connection.Open();

executeRowCount = cm.ExecuteNonQuery();
}
catch(Exception ex)
{
errorMsg = “运行runSql函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL ;
if (isUseTrans)
this.TranRollBack();
addLogErr(SQL,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
}
#endregion
///
/// 运行SQl语句返回第一条记录。返回DataRow
///
/// 查询语句。比如select * from tableName
///
#region 函数实现 — — runSqlDataRow
public DataRow runSqlDataRow(string SQL)
{
errorMsg = “0”;
cm.CommandText = SQL;
cm.CommandType = CommandType.Text;

DataRow DR = null;

SqlDataAdapter da = new SqlDataAdapter(cm);
try
{
DataTable DT = new DataTable();
da.Fill(DT);
DR = DT.Rows[0];
}
catch(Exception ex)
{
errorMsg = “运行runSqlDataRow函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL;
if (isUseTrans)
this.TranRollBack();
addLogErr(SQL,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
//if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
// cm.Connection.Open();

//SqlDataReader r = cm.ExecuteReader(CommandBehavior.SingleRow);
//if (r.Read())
// DR = r.GetSchemaTable().Rows[0];

//r.Close() ;

return DR;
}
#endregion

///
/// 运行SQl语句返回第一条记录的数组。返回字符串数组
///
/// 查询语句。比如select * from tableName
///
#region 函数实现 — — runSqlStrs
public string[] runSqlStrs(string SQL)
{
//返回ID 传入查询语句，返回第一条记录的第一的字段的值
string[] strValue;
errorMsg = “0”;
cm.CommandText=SQL;
cm.CommandType=CommandType.Text;
try
{
if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
cm.Connection.Open();

SqlDataReader r = cm.ExecuteReader(CommandBehavior.SingleRow);
if (r.Read() )
{
strValue = new string[r.FieldCount];
for(int i=0;i<r.FieldCount;i++)
strValue[i] = r.GetValue(i).ToString();
}
else
{
strValue=new string[1];
strValue[0]=“null”;
}
r.Close();
}
catch(Exception ex)
{
errorMsg = “运行runSqlStrs函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL;
strValue=new string[1];
strValue[0]=“null”;
if (isUseTrans)
this.TranRollBack();
addLogErr(SQL,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
return strValue;
}
#endregion
///
/// 运行SQl语句返回第一条记录的第一列的值。
///
/// 查询语句。比如select top 1 ID from tableName where userName=‘aa’。会返回ID的内容
///
#region 函数实现 — — runSqlGetID
public string runSqlGetID(string SQL)
{
errorMsg = “0”;
cm.CommandText = SQL;
cm.CommandType = CommandType.Text;
string str="";
try
{
if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
cm.Connection.Open();

str = cm.ExecuteScalar().ToString() ;
}
catch(Exception ex)
{
errorMsg = “运行runSqlGetID函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL;
if (isUseTrans)
this.TranRollBack();
addLogErr(SQL,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
return str;
}
#endregion
///
/// 执行一条SQL语句，看是否能查到记录有：返回true；没有返回false，用于判断是否重名
///
/// 查询语句。比如select ID from tableName where userName=‘aa’
///
#region 函数实现 — — runSqlExists
public bool runSqlExists( string SQL)
{
errorMsg = “0”;
cm.CommandText=SQL;
cm.CommandType=CommandType.Text;
bool re=false;
try
{
if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
cm.Connection.Open();

SqlDataReader r = cm.ExecuteReader(CommandBehavior.CloseConnection);
if (r.HasRows)
re=true;
r.Close();
}
catch(Exception ex)
{
errorMsg = “运行runSqlExists函数时出现错误。
错误信息：” + ex.Message;
if (isShowErrorSQL ) errorMsg +=“
查询语句：” + SQL;

addLogErr(SQL,errorMsg);
}
finally
{
if (!isUseTrans)
cm.Connection.Close();
}
return re;
}
#endregion
#endregion
#region 查询语句的方式添加、修改数据

///
/// 添加记录。传入表名，字段数组，值数组，返回新生成记录的ID
///
/// 要添加记录的表的名称
/// 字段名数组
/// 字段对应的值的数组
///
public string InsertDataStr(string TableName , string[] ziduan , string[] msg )
{
//添加数据返回新添加的ID
int i;
string Tables;
string msgs;
Tables = " (";
for( i = 0 ;i< ziduan.Length - 1;i++)
Tables += ziduan[i] + “,”;

Tables = Tables + ziduan[i] + ") “;
msgs = " values (’”;
for( i = 0;i<ziduan.Length - 1;i++)
msgs = msgs + msg[i] + “’,’”;

msgs = msgs + msg[i] + "’) ";
string insertStr = "insert into " + TableName + " " + Tables + msgs;
insertStr += " select scope_identity() as a1 ";
string re=runSqlGetID(insertStr);
return re;
}

///
/// 添加记录。传入表名，值数组（按照字段的物理顺序排列，不能有空），返回新生成记录的ID
///
/// 要添加记录的表的名称
/// 所有字段的值的数组
///
public string InsertDataStr(string TableName , string[] msg )
{
//添加数据，按标的字段顺序添加
int i;
//string Tables;
string msgs;
msgs = " values (’";
for( i = 0;i< msg.Length - 1;i++)
msgs = msgs + msg[i] + “’,’”;

msgs = msgs + msg[i] + "’) ";
string insertStr = "insert into " + TableName + " " + msgs;
insertStr += " select scope_identity() as a1 ";
string re=runSqlGetID(insertStr);
return re;
}
///
/// 修改记录。传入表名，字段数组，值数组
///
/// 要修改记录的表的名称
/// 字段名数组
/// 字段对应的值的数组
/// 条件，加在where 后面的语句
///
public bool UpdateData( string TableName ,string[] ziduan ,string[] msg ,string tiaojian)
{
int i;
string msgs;
msgs = " set ";
for (i = 0 ;i< ziduan.Length - 1;i++)
msgs += ziduan[i] + “=” + “’” + msg[i] + "’, ";

msgs += ziduan[i] + “=” + “’” + msg[i] + “’”;
string insertStr = "update " + TableName + " " + msgs + " where " + tiaojian;
runSql(insertStr);
return true;

}
#endregion

}
}

weixin_43930596

发布了33 篇原创文章 · 获赞 2 · 访问量 2084

私信关注

猜你喜欢