asp.net2.0(c#2.0)通用数据访问层
using System;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace Ahcom.Data
{
#region Encodes 枚举体
/// <summary>
/// 对字符串进行编码的方式
/// </summary>
public enum Encodes
{
/// <summary>
/// 不对字符串进行编码
/// </summary>
None,
/// <summary>
/// 使用 HTML 编码字符串
/// </summary>
HtmlEncode,
/// <summary>
/// 使用 URL 编码字符串
/// </summary>
UrlEncode,
}
#endregion
#region ExecuteNonQueryMode 枚举体
/// <summary>
/// 批量执行 SQL 语句的设置
/// </summary>
public enum ExecuteNonQueryMode
{
/// <summary>
/// 默认值，批量执行 SQL 语句时，遇到错误时终止执行后面的语句。
/// </summary>
ErrorStop = 0,
/// <summary>
/// 批量执行 SQL 语句时，遇到错误时仍然执行后面的语句。
/// </summary>
ErrorIgnore = 1,
/// <summary>
/// 以事务方式执行，遇到错误时回滚记录。
/// </summary>
Transaction = 2,
// /// <summary>
// /// 返回数据库受影响的行数总计。
// /// </summary>
// RetrunRowCount = 4,
//
// /// <summary>
// /// 返回已执行的 SQL 语句总计。
// /// </summary>
// ReturnExeCount = 8
}
#endregion
/// <summary>
/// GBC 数据库操作接口
/// </summary>
public interface IDb
{
#region Open 方法 +2 次重载。
/// <summary>
/// 打开数据源连接
/// </summary>
/// <returns>成功返回 true 失败返回 false</returns>
bool Open();
///// <summary>
///// 打开数据源连接
///// </summary>
///// <param name="errorPage">发生错误跳转的页面</param>
//void Open(string errorPage);
///// <summary>
///// 打开数据源连接
///// </summary>
///// <param name="errorPage">发生错误跳转的页面</param>
///// <param name="message">传递给页面的参数</param>
//void Open(string errorPage, string message);
#endregion
#region Close 方法。关闭数据源连接。
void Close();
#endregion
#region ThrowOnException、IsTransaction、IsOleDb... 访问器。
/// <summary>
/// 读取或设置连接超时时间
/// </summary>
int Timeout { get; set;}
/// <summary>
/// 读取或设置发生错误时是否抛出异常。
/// </summary>
bool ThrowOnException { get; set;}
/// <summary>
/// 判断当前的数据库是否支持事务。
/// </summary>
bool IsTransaction { get;}
/// <summary>
/// 判断当前是否是使用 OleDb 提供程序。
/// </summary>
bool IsOleDb { get;}
/// <summary>
/// 获取当前数据库服务器名称
/// </summary>
string ServerName { get;}
/// <summary>
/// 获取当前数据库服务器软件版本号
/// </summary>
string ServerVersion { get;}
/// <summary>
/// 获取当前数据库处理程序的版本号
/// </summary>
string ModuleVersion { get;}
/// <summary>
/// 获取当前数据库处理程序的作者
/// </summary>
string[] Author { get;}
/// <summary>
/// 获取最后一次错误信息
/// </summary>
Exception LastError{ get;}
#endregion
#region GetLastError 方法。
/// <summary>
/// 读取最后一次发生的错误，并清空异常信息。
/// </summary>
/// <returns>异常对像</returns>
Exception GetLastError();
#endregion
#region GetConnection 方法 +1 次重载。
/// <summary>
/// 获取当前连接对像
/// </summary>
/// <returns>活动连接对像</returns>
IDbConnection GetConnection();
#endregion
#region GetDataReader 方法 +1 次重载。
/// <summary>
/// 获取 DataReader 对像
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <returns>DataReader 对像</returns>
IDataReader GetDataReader(string selectCommand);
#endregion
#region ExecuteNonQuery 方法 +2 次重载。
/// <summary>
/// 执行一条非 SELECT 的 SQL 语句
/// </summary>
/// <param name="commandText">非 SELECT 命令文本</param>
/// <returns>成功数据库受影响的行数，失败返回 -1</returns>
int ExecuteNonQuery(string commandText);
/// <summary>
/// 执行一条非 SELECT 的 SQL 语句
/// </summary>
/// <param name="commandText">非 SELECT 命令文本</param>
/// <param name="parameters">传递给 SQL 的过程参数</param>
/// <returns></returns>
int ExecuteNonQuery(string commandText, params SqlParameter[] parameters);
/// <summary>
/// 以默认方式批量执行 SELECT 的 SQL 语句
/// </summary>
/// <param name="commandText">非 SELECT 命令文本数组</param>
/// <returns>返回已执行 SQL 语句的数量</returns>
int[] ExecuteNonQuery(string[] commandText);
/// <summary>
/// 以默认方式批量执行 SELECT 的 SQL 语句
/// </summary>
/// <param name="commandText">非 SELECT 命令文本数组</param>
/// <param name="mode">执行模式，详见 ExecuteNonQueryMode 枚举体说明</param>
/// <returns>视 mode 参数，返回已执行 SQL 语句的数量或数据库受影响行数的总计</returns>
int[] ExecuteNonQuery(string[] commandText, ExecuteNonQueryMode mode);
#endregion
#region ExecuteScalar 方法 +1 次重载。
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略额外的列或行。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <returns>成功返回结果集中第一行的第一列，失败返回 null</returns>
object ExecuteScalar(string selectCommand);
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略额外的列或行。注意：返回值会被转换成 Default 的类型
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="Default">查询失败或为 DBNull 参数时，函数返回的默认值</param>
/// <returns>成功返回结果集中第一行的第一列，失败返回 Default 值</returns>
object ExecuteScalar(string selectCommand, object Default);
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略额外的列或行。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="parameter">传递给存储过程的参数</param>
/// <returns>成功返回结果集中第一行的第一列，失败返回 null</returns>
object ExecuteScalar(string selectCommand, params SqlParameter[] parameter);
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略额外的列或行。注意：返回值会被转换成 Default 的类型
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="Default">查询失败或为 DBNull 参数时，函数返回的默认值</param>
/// <param name="parameter">传递给存储过程的参数</param>
/// <returns>成功返回结果集中第一行的第一列，失败返回 null</returns>
object ExecuteScalar(string selectCommand, object Default, params SqlParameter[] parameter);
#endregion
#region ExecuteProcedure 方法。执行存储过程
/// <summary>
/// 执行存储过程并返回 DataSet 结果集
/// </summary>
/// <param name="ProcedureName">存储过程的名称</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>DataSet 实例</returns>
DataSet ExecuteProcedure(string ProcedureName, params SqlParameter[] parameters);
#endregion
#region GetDataRow 方法 +1 次重载。
/// <summary>
/// 执行查询，并返回查询所返回的结果集中复制第一行。忽略额外的行。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <returns>成功返回结果集中第一行，失败返回 null</returns>
DataRow GetDataRow(string selectCommand);
///// <summary>
///// 执行查询，并返回查询所返回的结果集中复制指定的行。忽略额外的行。
///// </summary>
///// <param name="selectCommand">查询语句</param>
///// <param name="selectIndex">从其开始的从零开始的记录号</param>
///// <returns>成功返回结果集中第一行，失败返回 null</returns>
//DataRow GetDataRow(string selectCommand, int selectIndex);
///// <summary>
///// 执行查询，并返回查询所返回的结果集中复制指定的行。忽略额外的行。
///// </summary>
///// <param name="selectCommand">查询语句</param>
///// <param name="parameters">传递给存储过程的参数</param>
///// <returns>成功返回结果集中第一行，失败返回 null</returns>
//DataRow GetDataRow(string selectCommand, params SqlParameter[] parameters);
///// <summary>
///// 执行查询，并返回查询所返回的结果集中复制指定的行。忽略额外的行。
///// </summary>
///// <param name="selectCommand">查询语句</param>
///// <param name="selectindex">其开始的从零开始的记录号</param>
///// <param name="parameters">传递给存储过程的参数</param>
///// <returns>成功返回结果集中第一行，失败返回 null</returns>
//DataRow GetDataRow(string selectCommand, int selectindex, params SqlParameter[] parameters);
#endregion
#region GetDataSet 方法 +1 次重载。
/// <summary>
/// 执行查询，并返回 DataSet 对象。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="srcTable">用于表映射的源表的名称</param>
/// <returns>成功返回 DataSet 对像，失败返回 null</returns>
DataSet GetDataSet(string selectCommand, string srcTable);
/// <summary>
/// 执行查询，并返回 DataSet 对象。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="startRecord">从其开始的从零开始的记录号</param>
/// <param name="maxRecords">要检索的最大记录数</param>
/// <param name="srcTable">用于表映射的源表的名称</param>
/// <returns>成功返回 DataSet 对像，失败返回 null</returns>
DataSet GetDataSet(string selectCommand, int startRecord, int maxRecords, string srcTable);
#endregion
#region GetDataTable +2 次重载。
/// <summary>
/// 执行查询，并返回 DataTable 对像。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <returns>成功返回 DataTable 对像，失败返回 null</returns>
DataTable GetDataTable(string selectCommand);
/// <summary>
/// 执行查询，并返回 DataTable 对像。
/// </summary>
/// <param name="selectCommand">查询语句</param>
/// <param name="startRecord">从其开始的从零开始的记录号</param>
/// <param name="maxRecords">要检索的最大记录数</param>
/// <returns>成功返回 DataTable 对像，失败返回 null</returns>
DataTable GetDataTable(string selectCommand, int startRecord, int maxRecords);
/// <summary>
/// 执行带存储过程，并返回结果集
/// </summary>
/// <param name="selectCommand">存储过程名称</param>
/// <param name="parameters">参数数组</param>
/// <returns>DataTable实例</returns>
DataTable GetDataTable(string procedureName, params SqlParameter[] parameters);
#endregion
#region GetRecordCount 方法。
/// <summary>
/// 读取指定数据表的最大记录数
/// </summary>
/// <param name="srcTable">数据表名称</param>
/// <returns>记录总数</returns>
int GetRecordCount(string srcTable);
/// <summary>
/// 读取指定数据表某个字段的最大记录数
/// </summary>
/// <param name="srcTable">数据表名称</param>
/// <param name="srcField">字段名称</param>
/// <returns>记录总数</returns>
int GetRecordCount(string srcTable, string srcField);
#endregion
#region Format 方法 +12 次重载。将不同数据类型参数格式化为字符串。
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(string value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="encode">进行编码的类型(默认 HtmlEncode 类型)</param>
/// <returns>已格式化后的字符串</returns>
string Format(string value, Encodes encode);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="zeroToNull">视零长度字符串为 null 值(默认 true 值)</param>
/// <returns>已格式化后的字符串</returns>
string Format(string value, bool zeroToNull);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="zeroToNull">视零长度字符串为 null 值(默认 true 值)</param>
/// <param name="encode">进行编码的类型(默认 HtmlEncode 类型)</param>
/// <returns>已格式化后的字符串</returns>
string Format(string value, bool zeroToNull, Encodes encode);
/// <summary>
/// 格式化 value 参数为 LIKE 关键字所需要的字符串
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="like1">头部匹配符号</param>
/// <param name="like2">尾部匹配符号</param>
/// <returns>已格式化后的字符串</returns>
string Format(string value, char like1, char like2);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(bool value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(byte value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(int value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(long value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(float value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(double value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(DateTime value);
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
string Format(object value);
/// 过滤连续空格和 LIKE 关键字的特殊字符
/// </summary>
/// <param name="key">准备过滤特殊字符串源字符串</param>
/// <returns>已过滤特殊字符的字符串</returns>
string FormatKey(string key);
/// 过滤连续空格和 LIKE 关键字的特殊字符
/// </summary>
/// <param name="key">准备过滤特殊字符串源字符串</param>
/// <param name="replace">特殊字符的替换字符（默认为空格）</param>
/// <returns>已过滤特殊字符的字符串</returns>
string FormatKey(string key, string replace);
#endregion
#region DBNullConv 方法 +2 次重载。判断或转换 DBNull 数值。
/// <summary>
/// 测试 value 参数是否是 DBNull 并转换 DBNull 参数。注意：返回值会被转换成 nullPort 的数据类型
/// </summary>
/// <param name="value">任何数据类型</param>
/// <param name="isNull">value 为 DBNull 时的函数返回值。</param>
/// <returns>value 参数如果是 DBNull 返回 nullPort 参数，否则返回 value</returns>
object DBNullConv(object value, object nullPort);
/// <summary>
/// 根据 value 参数是否是 DBNull 而返回不同数值。
/// </summary>
/// <param name="value">任何数据类型</param>
/// <param name="isNull">value 为 DBNull(或 null) 参数时的函数返回值</param>
/// <param name="notNull">value 非 DBNull(或 null) 参数时的函数返回值</param>
/// <returns>value 参数如果是 DBNull 返回 isNull 参数，否则返回 notNull 参数</returns>
object DBNullConv(object value, object isNull, object notNull);
#endregion
#region Convert 方法 +10 次重载。转换数据类型
/// <summary>
/// 转换 object 为 bool 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">bool 默认值</param>
/// <returns>bool 数值</returns>
bool Convert(object value, bool Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">byte 默认值</param>
/// <returns>byte 数值</returns>
byte Convert(object value, byte Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">int 默认值</param>
/// <returns>int 数值</returns>
int Convert(object value, int Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">long 默认值</param>
/// <returns>long 数值</returns>
long Convert(object value, long Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">float 默认值</param>
/// <returns>float 数值</returns>
float Convert(object value, float Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">double 默认值</param>
/// <returns>double 数值</returns>
double Convert(object value, double Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">sbyte 默认值</param>
/// <returns>sbyte 数值</returns>
sbyte Convert(object value, sbyte Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">uint 默认值</param>
/// <returns>uint 数值</returns>
uint Convert(object value, uint Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">ulong 默认值</param>
/// <returns>ulong 数值</returns>
ulong Convert(object value, ulong Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">string 默认值</param>
/// <returns>string 数值</returns>
string Convert(object value, string Default);
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">DateTime 默认值</param>
/// <returns>DateTime 数值</returns>
DateTime Convert(object value, DateTime Default);
#endregion
}
/// <summary>
/// 为数据库操作提供公用的方法
/// </summary>
public abstract class DbMethod
{
#region Format 方法。
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(string value)
{
return Format(value, true, Encodes.HtmlEncode);
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="encode">进行编码的类型(默认 HtmlEncode 类型)</param>
/// <returns>已格式化后的字符串</returns>
public string Format(string value, Encodes encode)
{
return Format(value, true, encode);
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="zeroToNull">视零长度字符串为 null 值(默认 true 值)</param>
/// <returns>已格式化后的字符串</returns>
public string Format(string value, bool zeroToNull)
{
return Format(value, zeroToNull, Encodes.HtmlEncode);
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="zeroToNull">视零长度字符串为 null 值(默认 true 值)</param>
/// <param name="encode">进行编码的类型(默认 HtmlEncode 类型)</param>
/// <returns>已格式化后的字符串</returns>
public string Format(string value, bool zeroToNull, Encodes encode)
{
if (value == null)
{
return "NULL";
}
else if (value.Length == 0 && zeroToNull)
{
return "NULL";
}
else
{
value = "'" + value.Replace("'", "''") + "'";
if (encode == Encodes.HtmlEncode)
return System.Web.HttpContext.Current.Server.HtmlEncode(value);
else if (encode == Encodes.UrlEncode)
return System.Web.HttpContext.Current.Server.UrlEncode(value);
else
return value;
}
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(byte value)
{
return value.ToString();
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(int value)
{
return value.ToString();
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(float value)
{
return value.ToString();
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(double value)
{
return value.ToString();
}
public virtual string Format(long value)
{
return value.ToString();
}
public virtual string Format(DateTime value)
{
return "'" + value.ToString() + "'";
}
public virtual string Format(bool value)
{
return value ? "1" : "0";
}
/// <summary>
/// 格式化 value 参数为 SQL 语句所需要的字符串。
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <returns>已格式化后的字符串</returns>
public string Format(object value)
{
Type type = value.GetType();
if(value == null)
{
return "NULL";
}
else if (type == typeof(string))
{
return this.Format(System.Convert.ToString(value), true, Encodes.HtmlEncode);
}
else if (type == typeof(byte) || type == typeof(sbyte) || type == typeof(short) || type == typeof(ushort) || type == typeof(int) || type == typeof(float) || type == typeof(double))
{
return value.ToString();
}
else if (type == typeof(uint) || type == typeof(long))
{
return this.Format(System.Convert.ToInt64(value));
}
else if (type == typeof(ulong))
{
throw new ArgumentException("无法处理 ulong 类型的参数。", "value");
}
else
{
return this.Format(value.ToString());
}
}
/// <summary>
/// 格式化 value 参数为 LIKE 关键字所需要的字符串
/// </summary>
/// <param name="value">准备格式化的参数</param>
/// <param name="like1">头部匹配符号</param>
/// <param name="like2">尾部匹配符号</param>
/// <returns>已格式化后的字符串</returns>
public string Format(string value, char like1, char like2)
{
value = System.Text.RegularExpressions.Regex.Replace(value, "[\\s_\\^\\[\\]%]", "\x20"); // 滤除特殊字符
value = System.Text.RegularExpressions.Regex.Replace(value, "\\s{2,}", "\x20"); // 滤除连续的空格
value = value.Trim();
value = like1 + value.Replace('\x20', '%') + like2; // 替换空格为通配符
return "'" + value + "'";
}
#endregion
#region DBNullConv 方法。
/// <summary>
/// 测试 value 参数是否是 DBNull 并转换 DBNull 参数
/// </summary>
/// <param name="value">任何数据类型</param>
/// <param name="isNull">value 为 DBNull(或 null) 时的函数返回值。</param>
/// <returns>value 参数如果是 DBNull 返回 nullPort 参数，否则返回 value</returns>
public object DBNullConv(object value, object nullPort)
{
if (value == DBNull.Value || value == null)
return nullPort;
else
{
try
{
return System.Convert.ChangeType(value, nullPort.GetType());
}
catch
{
return nullPort;
}
}
}
/// <summary>
/// 根据 value 参数是否是 DBNull 而返回不同数值。
/// </summary>
/// <param name="value">任何数据类型</param>
/// <param name="isNull">value 为 DBNull(或 null) 参数时的函数返回值</param>
/// <param name="notNull">value 非 DBNull(或 null) 参数时的函数返回值</param>
/// <returns>value 参数如果是 DBNull 返回 isNull 参数，否则返回 notNull 参数</returns>
public object DBNullConv(object value, object isNull, object notNull)
{
if (value == DBNull.Value || value == null)
return isNull;
else
return notNull;
}
#endregion
#region Convert 方法 +10 次重载。转换数据类型
/// <summary>
/// 转换 object 为 bool 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">bool 默认值</param>
/// <returns>bool 数值</returns>
public bool Convert(object value, bool Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
{
unchecked
{
return ((long)value) != 0;
}
}
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">byte 默认值</param>
/// <returns>byte 数值</returns>
public byte Convert(object value, byte Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (byte)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">int 默认值</param>
/// <returns>int 数值</returns>
public int Convert(object value, int Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (int)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">long 默认值</param>
/// <returns>long 数值</returns>
public long Convert(object value, long Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (long)Default;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">float 默认值</param>
/// <returns>float 数值</returns>
public float Convert(object value, float Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (float)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">double 默认值</param>
/// <returns>double 数值</returns>
public double Convert(object value, double Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (double)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">sbyte 默认值</param>
/// <returns>sbyte 数值</returns>
public sbyte Convert(object value, sbyte Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (sbyte)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">uint 默认值</param>
/// <returns>uint 数值</returns>
public uint Convert(object value, uint Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (uint)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">ulong 默认值</param>
/// <returns>ulong 数值</returns>
public ulong Convert(object value, ulong Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
return (uint)value;
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">string 默认值</param>
/// <returns>string 数值</returns>
public string Convert(object value, string Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
{
try
{
return (string)value;
}
catch
{
return value.ToString();
}
}
}
catch
{
return Default;
}
}
/// <summary>
/// 转换 object 为 byte 型数据
/// </summary>
/// <param name="value">Object 实例</param>
/// <param name="Default">DateTime 默认值</param>
/// <returns>DateTime 数值</returns>
public DateTime Convert(object value, DateTime Default)
{
try
{
if (value == null || DBNull.Value.Equals(value))
return Default;
else
{
Type type = value.GetType();
if (type == typeof(string))
return DateTime.Parse((string)value);
else
return (DateTime)value;
}
}
catch
{
return Default;
}
}
#endregion
}
/// <summary>
/// 创建数据库处理类的实例
/// </summary>
public class DbInstance
{
#region 静态变量或常量
// 在 Web.config 文件中所指定的数据库操作类的名称。
const string __DbClassName = "DbServiceProvider";
static Type instance = null;
#endregion
#region 构造函数
static DbInstance()
{
try
{
instance = (Type)System.Web.HttpContext.Current.Application["__DbInstance_Instance"];
}
catch
{
instance = null;
}
}
private DbInstance(){}
#endregion
#region Create 方法 +1 次重载。创建数据库实例。
public static IDb Create()
{
return new DbSqlServer();
//string classname = string.Empty;
//if (instance == null)
//{
// classname = System.Web.Configuration.WebConfigurationManager.AppSettings[__DbClassName];
// if (classname == null)
// {
// throw new ArgumentNullException(__DbClassName, "Web.config 文件中 appSettings 节点下 <add key=\"" + __DbClassName + "\" value=\"[此处为数据库处理类的名称]\" /> 没有找到。");
// }
// else if (classname.Length == 0)
// {
// throw new ArgumentNullException(__DbClassName, "Web.config 文件中 appSettings 节点下 <add key=\"" + __DbClassName + "\" value=\"[此处为数据库处理类的名称]\" /> value 属性为空。");
// }
// instance = Type.GetType(classname);
// System.Web.HttpContext.Current.Application["__DbInstance_Instance"] = instance;
// if (instance == null) throw new ArgumentException("名称为 '" + classname + "' 的类没有找到，请确定是否拼写是否正确或者类名是否是完全名称(包括命名空间)。", classname);
//}
//try
//{
// return (IDb)System.Activator.CreateInstance(instance);
//}
//catch (Exception e)
//{
// throw new SystemException(classname + " 类实例无法转换 IDb 类型，请确定该类是否实现了 IDb 接口。", e);
//}
}
public static IDb Create(string DbClassName)
{
Type type = Type.GetType(DbClassName);
if (type == null)
{
throw new ArgumentException("名称为 '" + DbClassName + "' 的类没有找到，请确定是否拼写是否正确或者类名是否是完全名称(包括命名空间)。", DbClassName);
}
else
{
try
{
return (IDb)System.Activator.CreateInstance(type);
}
catch (Exception e)
{
throw new SystemException(DbClassName + " 类实例无法转换 IDb 类型，请确定该类是否实现了 IDb 接口。", e);
}
}
}
#endregion
#region DataBind 方法 +2 次重载。执行查询并将结果集绑定到 dataBindObject 对像上。
/// <summary>
/// 执行查询并将结果集绑定到 dataBindObject 对像上。dataBindObject 必须支持 DataSource 属性和 DataBind 方法
/// </summary>
/// <param name="dataBindObject">数据库绑定控件</param>
/// <param name="selectCommand">查询语句</param>
/// <param name="startRecord">从其开始的从零开始的记录号</param>
/// <param name="maxRecords">要检索的最大记录数</param>
/// <returns>成功返回 true；失败返回 false</returns>
public static bool DataBind(object dataBindObject, string selectCommand)
{
if (dataBindObject == null) throw new ArgumentNullException("dataBindObject", "参数 dataBindObject 不能为 null 值。");
DataTable dt;
try
{
IDb db = DbInstance.Create();
dt = db.GetDataTable(selectCommand);
if (dt == null) return false;
}
catch
{
return false;
}
Type type = dataBindObject.GetType();
System.Reflection.PropertyInfo pi = type.GetProperty("DataSource");
System.Reflection.MethodInfo mi = type.GetMethod("DataBind");
if (pi == null || mi == null) return false;
if (pi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataSource 属性。");
if (mi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataBind 方法。");
try
{
pi.SetValue(dataBindObject, dt, null);
mi.Invoke(dataBindObject, null);
}
catch
{
return false;
}
return true;
}
/// <summary>
/// 执行查询并将结果集绑定到 dataBindObject 对像上。dataBindObject 必须支持 DataSource 属性和 DataBind 方法
/// </summary>
/// <param name="dataBindObject">数据库绑定控件</param>
/// <param name="selectCommand">查询语句</param>
/// <param name="startRecord">从其开始的从零开始的记录号</param>
/// <param name="maxRecords">要检索的最大记录数</param>
/// <returns>成功返回 true；失败返回 false</returns>
public static bool DataBind(object dataBindObject, string selectCommand, int startRecord, int maxRecords)
{
if (dataBindObject == null) throw new ArgumentNullException("dataBindObject", "参数 dataBindObject 不能为 null 值。");
DataTable dt;
try
{
IDb db = DbInstance.Create();
dt = db.GetDataTable(selectCommand, startRecord, maxRecords);
if (dt == null) return false;
}
catch
{
return false;
}
Type type = dataBindObject.GetType();
System.Reflection.PropertyInfo pi = type.GetProperty("DataSource");
System.Reflection.MethodInfo mi = type.GetMethod("DataBind");
if (pi == null || mi == null) return false;
if (pi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataSource 属性。");
if (mi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataBind 方法。");
try
{
pi.SetValue(dataBindObject, dt, null);
mi.Invoke(dataBindObject, null);
}
catch
{
return false;
}
return true;
}
/// <summary>
/// 执行存储过程并将结果集绑定到 dataBindObject 对像上。dataBindObject 必须支持 DataSource 属性和 DataBind 方法
/// </summary>
/// <param name="dataBindObject">数据绑定控件对像</param>
/// <param name="procedureName">存储过程名称</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>成功返回 true；失败返回 false</returns>
public static bool DataBind(object dataBindObject, string procedureName, params SqlParameter[] parameters)
{
if (dataBindObject == null) throw new ArgumentNullException("dataBindObject", "参数 dataBindObject 不能为 null 值。");
DataTable dt;
try
{
IDb db = DbInstance.Create();
dt = db.GetDataTable(procedureName, parameters);
if (dt == null) return false;
}
catch
{
return false;
}
Type type = dataBindObject.GetType();
System.Reflection.PropertyInfo pi = type.GetProperty("DataSource");
System.Reflection.MethodInfo mi = type.GetMethod("DataBind");
if (pi == null || mi == null) return false;
if (pi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataSource 属性。");
if (mi == null) throw new InvalidOperationException("参数 dataBindObject 对像不支持 DataBind 方法。");
try
{
pi.SetValue(dataBindObject, dt, null);
mi.Invoke(dataBindObject, null);
}
catch
{
return false;
}
return true;
}
#endregion
}
/// <summary>
/// Microsoft SQL Server 操作类
/// </summary>
public class DbSqlServer : DbMethod, IDb
{
#region 静态变量。
const string ConnectionString = "packet size=4096;data source=%1;user id=%2;password=%3;initial catalog=%4;persist security info=True;Connect Timeout=%5";
const string __Source = "DbSource";
const string __Catalog = "DbCatalog";
const string __UserId = "DbUserId";
const string __Password = "DbPassword";
const string __TimeOut = "DbTimeOut";
const string __ConnectionString = "ConnectionString";
#endregion
#region 对像级变量。
SqlConnection Connection;
bool isUserOpen = false, isUserConstr = false, onThrow = false;
string connectionString = null;
Exception lastError = null;
DataSource source;
#endregion
#region DataSource 类
private class DataSource
{
public string Source;
public string UserId;
public string Password;
public string Catalog;
public int Timeout;
}
#endregion
#region 构造函数
/// <summary>
/// 初始化 DbSqlServer 实例
/// </summary>
public DbSqlServer()
{
string constr;
this.source = new DataSource();
// 读取 Web.config 文件中连接字符串设置。
constr = System.Web.Configuration.WebConfigurationManager.AppSettings[__ConnectionString];
if (constr == null || constr.Length == 0) // 未配置连接字符串，则继续读取相关配置。
{
string timeOut = System.Web.Configuration.WebConfigurationManager.AppSettings[__TimeOut];
try
{
if (timeOut == null || timeOut.Length == 0)
source.Timeout = 15;
else
source.Timeout = int.Parse(timeOut);
}
catch
{
source.Timeout = 15;
}
source.Source = System.Web.Configuration.WebConfigurationManager.AppSettings[__Source];
source.Catalog = System.Web.Configuration.WebConfigurationManager.AppSettings[__Catalog];
source.UserId = System.Web.Configuration.WebConfigurationManager.AppSettings[__UserId];
source.Password = System.Web.Configuration.WebConfigurationManager.AppSettings[__Password];
}
else
{
this.connectionString = constr;
this.Connection = new SqlConnection(this.connectionString);
this.isUserConstr = true;
return;
}
if (source.Source == null && source.Catalog == null && source.UserId == null && source.Password == null)
{
throw new SystemException("请配置 Web.config 文件 appSettings 子节点中 <add key=\"" + __ConnectionString + "\" value=\"[连接字符串]\" /> 或者分别每个 add 节点中配置数据源(<add key=\"" + __Source + "\" value=\"[数据源名称]\" />)、数据库(<add key=\"" + __Catalog + "\" value=\"[数据库名称]\" />)、用户名(<add key=\"" + __UserId + "\" value=\"[连接用户名]\" />)和用户密码(<add key=\"" + __Password + "\" value=\"[连接密码]\" />)");
}
else
{
if (this.source.Source == null || this.source.Source.Length == 0) throw new ArgumentNullException(__Source, "Web.config 文件 appSettings 节点中 <add key=\"" + __Source + "\" value=\"[您设置的参数]\" /> 没有找到或 value 属性不正确。");
if (this.source.Catalog == null || this.source.Catalog.Length == 0) throw new ArgumentNullException(__Catalog, "Web.config 文件 appSettings 节点中 <add key=\"" + __Catalog + "\" value=\"[您设置的参数]\" /> 没有找到或 value 属性不正确。");
if (this.source.UserId == null || this.source.UserId.Length == 0) throw new ArgumentNullException(__UserId, "Web.config 文件 appSettings 节点中 <add key=\"" + __UserId + "\" value=\"[您设置的参数]\" /> 没有找到或 value 属性不正确。");
if (this.source.Password == null) throw new ArgumentNullException(__Password, "Web.config 文件 appSettings 节点中 <add key=\"" + __Password + "\" value=\"[您设置的参数]\" /> 没有找到或 value 属性不正确。");
this.connectionString = ConnectionString.Replace("%1", this.source.Source);
this.connectionString = this.connectionString.Replace("%2", this.source.UserId);
this.connectionString = this.connectionString.Replace("%3", this.source.Password);
this.connectionString = this.connectionString.Replace("%4", this.source.Catalog);
this.connectionString = this.connectionString.Replace("%5", this.source.Timeout.ToString());
this.isUserConstr = false;
}
this.Connection = new SqlConnection(this.connectionString);
}
#endregion
#region Open 方法 +2 次重载
/// <summary>
/// 打开数据源连接
/// </summary>
/// <returns>成功返回 true 否则返回 false</returns>
public bool Open()
{
try
{
this.isUserOpen = true;
this.lastError = null;
if (this.Connection.State != ConnectionState.Closed)
{
return true;
}
else
{
this.Connection.Open();
return true;
}
}
catch (Exception e)
{
this.lastError = e;
if (this.onThrow) throw e;
return false;
}
}
//public void Open(string errorPage)
//{
// this.Open(errorPage, "本站正在技术维护中，暂不能提供任何信息，欢迎稍后访问。");
//}
//public void Open(string errorPage, string message)
//{
// this.isUserOpen = true;
// this.Open();
// if (this.lastError != null)
// {
// message = System.Web.HttpContext.Current.Server.UrlEncode(message);
// if (errorPage.IndexOf("?") != -1)
// System.Web.HttpContext.Current.Response.Redirect(errorPage + "?errmsg=" + message);
// else
// System.Web.HttpContext.Current.Response.Redirect(errorPage + "&errmsg=" + message);
// }
//}
public void Close()
{
try
{
this.Connection.Close();
}
finally
{
this.isUserOpen = false;
}
}
#endregion
#region ActiveConnection、Timeout、ThrowOnException、IsTransaction、IsOleDb... 访问器
private SqlConnection ActiveConnection
{
get
{
try
{
this.lastError = null;
if (this.Connection.State != ConnectionState.Closed)
{
return this.Connection;
}
else
{
this.Connection.Open();
return this.Connection;
}
}
catch (Exception e)
{
this.lastError = e;
if (this.onThrow) throw e;
return null;
}
}
set
{
if (!this.isUserOpen) this.Close();
}
}
public int Timeout
{
get { return this.source.Timeout; }
set
{
if (value > 0)
this.source.Timeout = value;
else if (this.onThrow)
throw new ArgumentOutOfRangeException("Timeout", value, "超时时间设置不能小于零。");
if (!this.isUserConstr)
{
this.connectionString = ConnectionString.Replace("%1", source.Source);
this.connectionString = this.connectionString.Replace("%2", source.UserId);
this.connectionString = this.connectionString.Replace("%3", source.Password);
this.connectionString = this.connectionString.Replace("%4", source.Catalog);
this.connectionString = this.connectionString.Replace("%5", source.Timeout.ToString());
ConnectionState state = this.Connection.State;
if (state != ConnectionState.Closed) this.Close();
this.Connection.ConnectionString = this.connectionString;
if (state == ConnectionState.Open) this.Open();
}
}
}
public bool ThrowOnException
{
get{ return this.onThrow; }
set { this.onThrow = value; }
}
public bool IsTransaction { get { return true; } }
public bool IsOleDb { get { return false; } }
public string ServerName
{
get
{
DataRow row;
try
{
row = this.GetDataRow("USE master;EXEC xp_msver;");
return row["Character_Value"].ToString();
}
catch
{
return null;
}
}
}
public string ServerVersion
{
get
{
DataRow row;
try
{
row = this.GetDataRow("USE master;EXEC xp_msver;");
return row["Character_Value"].ToString();
}
catch
{
return null;
}
}
}
public string ModuleVersion
{
get { return "1.0"; }
}
public string[] Author
{
get { return new string[1] { "\u6F58\u6653\u5CF0" }; }
}
/// <summary>
/// 最后一次发生错误的信息（注意：访问此属性不会清空错误信息）
/// </summary>
public Exception LastError
{
get { return this.lastError; }
}
#endregion
#region GetLastError 方法
/// <summary>
/// 最后一次发生错误的信息（注意：访问此方法会清空错误信息）
/// </summary>
/// <returns>返回最后一次发生错误的信息</returns>
public Exception GetLastError()
{
try
{
return this.lastError;
}
finally
{
this.lastError = null;
}
}
#endregion
#region GetConnection 方法
public IDbConnection GetConnection()
{
return this.Connection;
}
#endregion
#region GetDataReader 方法
public IDataReader GetDataReader(string selectCommand)
{
try
{
this.lastError = null;
SqlCommand cmd = new SqlCommand(selectCommand, this.ActiveConnection);
SqlDataReader dr = cmd.ExecuteReader();
return dr;
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
//this.ActiveConnection = null;
}
}
#endregion
#region ExecuteNonQuery 方法 +3 次重载
public int ExecuteNonQuery(string commandText)
{
return this.ExecuteNonQuery(commandText, null);
}
public int ExecuteNonQuery(string commandText, params SqlParameter[] parameters)
{
try
{
this.lastError = null;
SqlCommand cmd = new SqlCommand(commandText, this.ActiveConnection);
if (parameters != null)
foreach (SqlParameter parameter in parameters)
if (parameter != null)
cmd.Parameters.Add(parameter);
return cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return -1;
}
finally
{
this.ActiveConnection = null;
}
}
public int[] ExecuteNonQuery(string[] commandText)
{
return this.ExecuteNonQuery(commandText, ExecuteNonQueryMode.Transaction);
}
public int[] ExecuteNonQuery(string[] commandText, ExecuteNonQueryMode mode)
{
int[] result;
SqlTransaction tran = null;
try
{
if (commandText == null || commandText.Length == 0) return null;
result = new int[commandText.Length];
tran = null;
this.lastError = null;
SqlCommand cmd = new SqlCommand();
cmd.Connection = this.ActiveConnection;
if (mode == ExecuteNonQueryMode.Transaction)
{
tran = this.Connection.BeginTransaction();
cmd.Transaction = tran;
}
for (int index = 0; index < result.Length; index++)
{
try
{
if (commandText[index] != null && commandText[index].Length > 0)
{
cmd.CommandText = commandText[index];
result[index] = cmd.ExecuteNonQuery();
}
else
{
result[index] = 0;
}
}
catch (Exception e)
{
result[index] = -1;
if (mode == ExecuteNonQueryMode.Transaction) // 以事务方式
{
tran.Rollback();
if (this.onThrow)
throw e;
else
this.lastError = e;
return null;
}
else if (mode == ExecuteNonQueryMode.ErrorStop) // 遇错结束方式
{
if (this.onThrow)
throw e;
else
this.lastError = e;
return result;
}
else // 忽略错误方式
{
continue;
}
}
}
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
if (mode == ExecuteNonQueryMode.Transaction) tran.Commit();
this.ActiveConnection = null;
}
return result;
}
#endregion
#region ExecuteScalar 方法 +3 次重载
public object ExecuteScalar(string selectCommand)
{
return this.ExecuteScalar(selectCommand, null, null);
}
public object ExecuteScalar(string selectCommand, object Default)
{
return this.ExecuteScalar(selectCommand, Default, null);
}
public object ExecuteScalar(string selectCommand, params SqlParameter[] parameters)
{
return this.ExecuteScalar(selectCommand, null, parameters);
}
public object ExecuteScalar(string selectCommand, object Default, params SqlParameter[] parameters)
{
try
{
this.lastError = null;
SqlCommand cmd = new SqlCommand(selectCommand, this.ActiveConnection);
if (parameters != null && parameters.Length != 0)
for (int index = 0; index < parameters.Length; index++)
if (parameters[index] != null)
cmd.Parameters.Add(parameters[index]);
object result = cmd.ExecuteScalar();
try
{
if (Default != null)
return System.Convert.ChangeType(result, Default.GetType());
else
return result;
}
catch
{
return Default;
}
finally
{
this.ActiveConnection = null;
}
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) return ex;
return Default;
}
}
#endregion
#region ExecuteProcedure 方法。执行存储过程
/// <summary>
/// 执行存储过程并返回 DataSet 结果集
/// </summary>
/// <param name="ProcedureName">存储过程的名称</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>DataSet 实例</returns>
public DataSet ExecuteProcedure(string ProcedureName, params SqlParameter[] parameters)
{
SqlDataReader dr = null;
try
{
this.lastError = null;
SqlCommand cmd = new SqlCommand(ProcedureName, this.ActiveConnection);
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = ProcedureName;
if (parameters != null)
foreach (SqlParameter parameter in parameters)
if (parameter != null) cmd.Parameters.Add(parameter);
dr = cmd.ExecuteReader();
DataSet ds = new DataSet();
do
{
DataTable dt = new DataTable();
dt.Load(dr);
ds.Tables.Add(dt);
}
while (dr.NextResult());
return ds;
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
if(dr != null) dr.Close();
this.ActiveConnection = null;
}
}
#endregion
#region GetDataRow 方法
public DataRow GetDataRow(string selectCommand)
{
DataTable dt;
DataSet ds = new DataSet();
try
{
this.lastError = null;
SqlDataAdapter da = new SqlDataAdapter(selectCommand, this.ActiveConnection);
da.Fill(ds, 0, 1, "table");
dt = new DataTable();
foreach(DataColumn dc in ds.Tables[0].Columns)
dt.Columns.Add(new DataColumn(dc.ColumnName, dc.DataType));
DataRow row = dt.NewRow();
for(int index=0;index<ds.Tables[0].Columns.Count;index++)
{
row[index] = System.Convert.ChangeType(ds.Tables[0].Rows[0][index], ds.Tables[0].Rows[0][index].GetType());
}
ds.Dispose();
return row;
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
this.ActiveConnection = null;
ds.Dispose();
}
}
#endregion
#region GetDataSet 方法 +1 次重载
public DataSet GetDataSet(string selectCommand, string srcTable)
{
try
{
this.lastError = null;
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(selectCommand, this.ActiveConnection);
da.Fill(ds);
return ds;
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
this.ActiveConnection = null;
}
}
public DataSet GetDataSet(string selectCommand, int startRecord, int maxRecords, string srcTable)
{
try
{
this.lastError = null;
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(selectCommand, this.ActiveConnection);
da.Fill(ds);
return ds;
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
this.ActiveConnection = null;
}
}
#endregion
#region GetDataTable 方法 +2 次重载
public DataTable GetDataTable(string selectCommand)
{
try
{
this.lastError = null;
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(selectCommand,this.ActiveConnection);
da.Fill(ds);
return ds.Tables[0];
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
this.ActiveConnection = null;
}
}
public DataTable GetDataTable(string selectCommand, int startRecord, int maxRecords)
{
try
{
this.lastError = null;
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(selectCommand, this.ActiveConnection);
da.Fill(ds, startRecord, maxRecords, "table1");
return ds.Tables[0];
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return null;
}
finally
{
this.ActiveConnection = null;
}
}
public DataTable GetDataTable(string procedureName, params SqlParameter[] parameters)
{
SqlDataReader dr = null;
try
{
SqlCommand cmd = new SqlCommand(procedureName, this.ActiveConnection);
cmd.CommandType = CommandType.StoredProcedure;
if (parameters != null)
foreach (SqlParameter parameter in parameters)
if (parameter != null) cmd.Parameters.Add(parameter);
DataTable dt = new DataTable();
dr = cmd.ExecuteReader();
dt.Load(dr);
return dt;
}
catch(Exception ex)
{
this.lastError = ex;
if(this.onThrow) throw ex;
return null;
}
finally
{
if(dr != null) dr.Close();
this.ActiveConnection = null;
}
}
#endregion
#region GetRecordCount 方法 +1 次重载
public int GetRecordCount(string srcTable)
{
try
{
this.lastError = null;
string selectCommand = "SELECT COUNT(*) FROM [" + srcTable.TrimStart('[').TrimEnd(']') + "];";
return (int)this.ExecuteScalar(selectCommand);
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return -1;
}
}
public int GetRecordCount(string srcTable, string srcField)
{
try
{
this.lastError = null;
if (srcField == null || srcField.Length == 0)
srcField = "*";
else
srcField = "[" + srcField.TrimStart('[').TrimEnd(']') + "]";
srcTable = "[" + srcTable.TrimStart('[').TrimEnd(']') + "]";
string selectCommand = "SELECT COUNT(" + srcField + ") FROM " + srcTable + ";";
return (int)this.ExecuteScalar(selectCommand);
}
catch (Exception ex)
{
this.lastError = ex;
if (this.onThrow) throw ex;
return -1;
}
finally
{
this.ActiveConnection = null;
}
}
#endregion
#region Format 方法
public override string Format(long value)
{
return "CAST(" + value.ToString() + " AS BIGINT)";
}
/// 过滤连续空格和 LIKE 关键字的特殊字符
/// </summary>
/// <param name="key">准备过滤特殊字符串源字符串</param>
/// <returns>已过滤特殊字符的字符串</returns>
public string FormatKey(string key)
{
return FormatKey(key, "\x20");
}
/// <summary>
/// 过滤连续空格和 LIKE 关键字的特殊字符（
/// </summary>
/// <param name="key">准备过滤特殊字符串源字符串</param>
/// <param name="replace">特殊字符的替换字符（默认为空格）</param>
/// <returns>已过滤特殊字符的字符串</returns>
public string FormatKey(string key, string replace)
{
key = System.Text.RegularExpressions.Regex.Replace(key, "[\\s_\\^\\[\\]%]", replace); // 滤除特殊字符
key = System.Text.RegularExpressions.Regex.Replace(key, "\\s{2,}", replace); // 滤除连续的空格
key = key.Replace("'", "''");
key = key.Trim();
return key;
}
#endregion
}
}
