CREATE PROCEDURE [dbo].[RecordFromPage]
@SelectList VARCHAR(max),
@TableSource VARCHAR(100),
@SearchCondition VARCHAR(max),
@OrderExpression VARCHAR(1000),
@PageIndex INT = 1,
@PageSize INT = 10,
@TotalCount int output
AS
BEGIN
IF @SelectList IS NULL OR LTRIM(RTRIM(@SelectList)) = ''
BEGIN
SET @SelectList = '*'
END
PRINT @SelectList SET @SearchCondition = ISNULL(@SearchCondition,'')
SET @SearchCondition = LTRIM(RTRIM(@SearchCondition))
IF @SearchCondition <> ''
BEGIN
IF UPPER(SUBSTRING(@SearchCondition,1,5)) <> 'WHERE'
BEGIN
SET @SearchCondition = 'WHERE ' + @SearchCondition
END
END
PRINT @SearchCondition SET @OrderExpression = ISNULL(@OrderExpression,'')
SET @OrderExpression = LTRIM(RTRIM(@OrderExpression))
IF @OrderExpression <> ''
BEGIN
IF UPPER(SUBSTRING(@OrderExpression,1,5)) <> 'WHERE'
BEGIN
SET @OrderExpression = 'ORDER BY ' + @OrderExpression
END
END
PRINT @OrderExpression IF @PageIndex IS NULL OR @PageIndex < 1
BEGIN
SET @PageIndex = 1
END
PRINT @PageIndex
IF @PageSize IS NULL OR @PageSize < 1
BEGIN
SET @PageSize = 10
END
PRINT @PageSize DECLARE @Total int
DECLARE @Sql nVarchar(max)
SET @Sql=(N'SELECT @Total=Count(*) FROM ' + @TableSource +' '+ @SearchCondition)
print @sql
Exec sp_executesql @Sql, N'@Total Int Out',@Total Out
set @TotalCount=@Total
DECLARE @SqlQuery VARCHAR(max) SET @SqlQuery='SELECT '+@SelectList+',RowNumber
FROM
(SELECT ' + @SelectList + ',ROW_NUMBER() OVER( '+ @OrderExpression +') AS RowNumber
FROM '+@TableSource+' '+ @SearchCondition +') AS RowNumberTableSource
WHERE RowNumber BETWEEN ' + CAST(((@PageIndex - 1)* @PageSize+1) AS VARCHAR)
+ ' AND ' +
CAST((@PageIndex * @PageSize) AS VARCHAR)
-- ORDER BY ' + @OrderExpression
PRINT @SqlQuery
SET NOCOUNT ON
EXECUTE(@SqlQuery)
SET NOCOUNT OFF END

  

/// <summary>
/// 查询接口
/// </summary>
public interface IQuery
{
string Column { get; set; } //列名
string TableName { get; set; } //表名
string OrderBy { get; set; } //查询的"OrderBy"语句,不包含OrderBy,例子:ID DESC
string BulidQuery(); //查询的"where"语句
string BulidSelect(string where, string tableName = ""); //查语句
}
/// <summary>
/// 分页实现简单查询
/// </summary>
public class CommonPageSql
{ /// <summary>
/// 分页获取数据列表 适用于SQL2005和SQL2008
/// </summary>
/// <param name="con">数据库连接字符串</param>
/// <param name="pageindex">页索引 从0开始</param>
/// <param name="pagesize">每页记录数</param>
/// <param name="query">查询接口</param>
/// <param name="p">输出参数</param>
/// <returns>DataRead数据集</returns>
public static IDataReader GetDataReaderByPager(string con, int pageindex, int pagesize, IQuery query, out SqlParameter p)
{
string cmd = "RecordFromPage";
SqlParameter[] para = SqlHelperParameterCache.GetSpParameterSet(con, cmd);
para[].Value = query.Column;
para[].Value = query.TableName;
para[].Value = query.BulidQuery();
para[].Value = query.OrderBy;
para[].Value = pageindex;
para[].Value = pagesize;
para[].Direction = ParameterDirection.Output;
//SqlParameter[] para = new SqlParameter[7];
//para[0] = new SqlParameter("@SelectList", query.Column);
//para[1] = new SqlParameter("@TableSource", query.TableName);
//para[2] = new SqlParameter("@SearchCondition", query.BulidQuery());
//para[3] = new SqlParameter("@OrderExpression", query.OrderBy);
//para[4] = new SqlParameter("@pageindex", pageindex);
//para[5] = new SqlParameter("@pagesize", pagesize);
//para[6] = new SqlParameter("@TotalCount", SqlDbType.Int);
//para[6].Direction = ParameterDirection.Output;
IDataReader reader = SqlHelper.ExecuteReader(con, CommandType.StoredProcedure, cmd, para);
p = para[];
return reader;
} /// <summary>
/// 分页获取数据列表 适用于SQL2005和SQL2008
/// </summary>
/// <param name="con">数据库连接字符串</param>
/// <param name="pageindex">页索引 从0开始</param>
/// <param name="pagesize">每页记录数</param>
/// <param name="query">查询接口</param>
/// <param name="p">输出参数</param>
/// <returns>DataTable数据集</returns>
public static DataTable GetDataByPager(string con, int pageindex, int pagesize, IQuery query, out SqlParameter p)
{
string cmd = "RecordFromPage";
SqlParameter[] para = SqlHelperParameterCache.GetSpParameterSet(con, cmd);
para[].Value = query.Column;
para[].Value = query.TableName;
para[].Value = query.BulidQuery();
para[].Value = query.OrderBy;
para[].Value = pageindex;
para[].Value = pagesize;
para[].Direction = ParameterDirection.Output;
DataTable datatable = SqlHelper.ExecuteDataset(con,CommandType.StoredProcedure,cmd,para).Tables[];
p = para[];
return datatable;
}
}
/// <summary>
/// 简单查询帮助类
/// </summary>
public class CommonSelectSql
{
#region DataReader
/// <summary>
/// 获取数据
/// </summary>
/// <param name="con">数据库连接字符串</param>
/// <param name="top">前几条</param>
/// <param name="Query">查询构建类</param>
/// <returns>DataReader数据表</returns>
public static IDataReader SelectGetReader(string con,int top,IQuery Query)
{
return GetDataReader(con,top, Query.TableName, Query.Column, Query.BulidQuery(), Query.OrderBy);
} /// <summary>
/// 获得前几行数据
/// </summary>
/// <param name="connstring">数据库连接字符串</param>
/// <param name="Top">几条记录</param>
/// <param name="tableName">表名</param>
/// <param name="Column">列名</param>
/// <param name="strWhere">查询条件</param>
/// <param name="filedOrder">排序方式</param>
/// <returns>DataReader数据表</returns>
private static IDataReader GetDataReader(string connstring,int Top, string tableName, string Column, string strWhere, string filedOrder)
{
StringBuilder strSql = new StringBuilder();
strSql.AppendFormat("SELECT * FROM(SELECT ROW_NUMBER() OVER(ORDER BY {0}) ROWNUM,", filedOrder);
if (!string.IsNullOrEmpty(Column))
{
strSql.Append(Column);
}
else
{
strSql.Append("*");
}
strSql.Append(" FROM " + tableName);
if (strWhere.Trim() != "")
{
strSql.Append(" where " + strWhere + ") T");
}
else
{
strSql.Append(") T");
}
if (Top > )
{
strSql.AppendFormat(" WHERE T.ROWNUM <= {0}",Top);
}
return SqlHelper.ExecuteReader(connstring, CommandType.Text, strSql.ToString());
}
#endregion #region DataTable /// <summary>
/// 获取数据
/// </summary>
/// <param name="con">数据库连接字符串</param>
/// <param name="top">前几条</param>
/// <param name="Query">查询构建类</param>
/// <returns>DataTable数据表</returns>
public static DataTable SelectGetTable(string con, int top, IQuery Query)
{
return GetDataTable(con, top, Query.TableName, Query.Column, Query.BulidQuery(), Query.OrderBy);
} /// <summary>
/// 获得前几行数据
/// </summary>
/// <param name="con">数据库连接字符串</param>
/// <param name="Top">几条记录</param>
/// <param name="tableName">表名</param>
/// <param name="Column">列名</param>
/// <param name="strWhere">查询条件</param>
/// <param name="filedOrder">排序方式</param>
/// <returns>DataTable数据表</returns>
private static DataTable GetDataTable(string con,int Top, string tableName, string Column, string strWhere, string filedOrder)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("select ");
if (Top > )
{
strSql.Append(" top " + Top.ToString());
}
strSql.Append(Column);
strSql.Append(" FROM " + tableName);
if (strWhere.Trim() != "")
{
strSql.Append(" where " + strWhere);
}
strSql.Append(" order by " + filedOrder);
return SqlHelper.ExecuteDataset(con,CommandType.Text,strSql.ToString()).Tables[];
}
#endregion
}
/// <summary>
/// 用来缓存SqlParameter
/// </summary>
public sealed class SqlHelperParameterCache
{
#region 私有方法,变量,跟构造函数 private SqlHelperParameterCache() { } private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable()); /// <summary>
/// 返回存储过程中的参数信息
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="includeReturnValueParameter">是否返回需要返回的参数@RETURN_VALUE</param>
/// <returns>返回的参数数组.</returns>
private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); SqlCommand cmd = new SqlCommand(spName, connection);
cmd.CommandType = CommandType.StoredProcedure; connection.Open();
SqlCommandBuilder.DeriveParameters(cmd);
connection.Close(); if (!includeReturnValueParameter)
{
cmd.Parameters.RemoveAt();
} SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count]; cmd.Parameters.CopyTo(discoveredParameters, ); foreach (SqlParameter discoveredParameter in discoveredParameters)
{
discoveredParameter.Value = DBNull.Value;
}
return discoveredParameters;
} /// <summary>
/// 复制一份参数数组
/// </summary>
/// <param name="originalParameters">参数数组</param>
/// <returns>参数数组</returns>
private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
{
SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length]; for (int i = , j = originalParameters.Length; i < j; i++)
{
clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone();
} return clonedParameters;
} #endregion #region 缓存方法 /// <summary>
/// 将参数数组添加到缓存
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("connectionString");
if (commandText == null || commandText.Length == ) throw new ArgumentNullException("commandText"); string hashKey = connectionString + ":" + commandText; paramCache[hashKey] = commandParameters;
} /// <summary>
/// 从缓存里获取参数数组
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>参数数组</returns>
public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (commandText == null || commandText.Length == ) throw new ArgumentNullException("没有提供存储过程的名字或者 T-SQL 语句"); string hashKey = connectionString + ":" + commandText; SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[];
if (cachedParameters == null)
{
return null;
}
else
{
return CloneParameters(cachedParameters);
}
} #endregion caching functions #region 获取参数 /// <summary>
/// 通过存储过程名跟连接字符串获取缓存中的参数数组
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <returns>参数数组</returns>
public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
{
return GetSpParameterSet(connectionString, spName, false);
} /// <summary>
/// 通过存储过程名跟连接字符串获取缓存中的参数数组
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="includeReturnValueParameter">是否返回输出参数</param>
/// <returns>参数数组</returns>
public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); using (SqlConnection connection = new SqlConnection(connectionString))
{
return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
}
} /// <summary>
/// 通过数据库连接对象获取缓存中的参数数组
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程名</param>
/// <returns>参数数组</returns>
internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName)
{
return GetSpParameterSet(connection, spName, false);
} /// <summary>
/// 通过数据库连接对象获取缓存中的参数数组
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="includeReturnValueParameter">是否返回输出参数</param>
/// <returns>参数数组</returns>
internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone())
{
return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
}
} /// <summary>
/// 通过数据库连接对象获取缓存中的参数数组
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="includeReturnValueParameter">是否返回输出参数</param>
/// <returns>参数数组</returns>
private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); string hashKey = connection.ConnectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : ""); SqlParameter[] cachedParameters; cachedParameters = paramCache[hashKey] as SqlParameter[];
if (cachedParameters == null)
{
SqlParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter);
paramCache[hashKey] = spParameters;
cachedParameters = spParameters;
} return CloneParameters(cachedParameters);
} #endregion }
/// <summary>
/// 封装数据库操作方法
/// </summary>
public abstract class SqlHelper
{
#region 私有方法以及构造方法 //不允许建立实例
private SqlHelper() { } //获取数据库连接
public static SqlConnection GetSqlConnection(string con)
{ try
{
return new SqlConnection(con);
}
catch
{
throw new Exception("连接出错");
} } /// <summary>
/// 这个方法给SqlCommand添加参数
/// </summary>
/// <param name="command">需要添加参数的command</param>
/// <param name="commandParameters">参数数组</param>
private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
{
if (command == null) throw new ArgumentNullException("command");
if (commandParameters != null)
{
foreach (SqlParameter p in commandParameters)
{
if (p != null)
{
// 检查当为输入参数时赋予默认值
if ((p.Direction == ParameterDirection.InputOutput ||
p.Direction == ParameterDirection.Input) &&
(p.Value == null))
{
p.Value = DBNull.Value;
}
command.Parameters.Add(p);
}
}
}
} /// <summary>
/// 这个方法使用的DataRow列的值填充SqlParameter数组
/// </summary>
/// <param name="commandParameters">需要填充到SqlParameter数组的DataRow</param>
/// <param name="dataRow">需要用到的DataRow</param>
private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow)
{
if ((commandParameters == null) || (dataRow == null))
{
return;
} int i = ;
foreach (SqlParameter commandParameter in commandParameters)
{
if (commandParameter.ParameterName == null ||
commandParameter.ParameterName.Length <= )
throw new Exception(
"没有给SqlParameter赋予ParameterName");
if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring()) != -)
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring()];
i++;
}
} /// <summary>
/// 给SqlParameter数组赋值
/// </summary>
/// <param name="commandParameters">SqlParameter数组</param>
/// <param name="parameterValues">参数值的数组</param>
private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues)
{
if ((commandParameters == null) || (parameterValues == null))
{
return;
} if (commandParameters.Length != parameterValues.Length)
{
throw new ArgumentException("SqlParameter数组的长度跟参数值的数组的长度不匹配");
} // Iterate through the SqlParameters, assigning the values from the corresponding position in the
// value array
for (int i = , j = commandParameters.Length; i < j; i++)
{
// 如果目前的数组值来自IDbDataParameter 则填充
if (parameterValues[i] is IDbDataParameter)
{
IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i];
if (paramInstance.Value == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = paramInstance.Value;
}
}
else if (parameterValues[i] == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = parameterValues[i];
}
}
} /// <summary>
/// 为执行sql命令做准备
/// </summary>
/// <param name="command">sql指令</param>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">数据库事务</param>
/// <param name="commandType">指令类型</param>
/// <param name="commandText">sql语句或存储过程</param>
/// <param name="commandParameters">执行sql需要传入的参数</param>
/// <param name="mustCloseConnection">如果sql连接还没有关闭着返回true</param>
private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection)
{
if (command == null) throw new ArgumentNullException("缺少SqlCommand参数");
if (commandText == null || commandText.Length == ) throw new ArgumentNullException("缺少sql语句或存储过程语句"); //当数据库没有连接则连接
if (connection.State != ConnectionState.Open)
{
mustCloseConnection = true;
connection.Open();
}
else
{
mustCloseConnection = true;
}
command.Connection = connection;
command.CommandText = commandText; if (transaction != null)
{
if (transaction.Connection == null) throw new ArgumentException("请提供一个已经打开的事务", "transaction");
command.Transaction = transaction;
}
command.CommandType = commandType; if (commandParameters != null)
{
AttachParameters(command, commandParameters);
}
return;
} #endregion #region ExecuteNonQuery /// <summary>
///执行的SqlCommand (返回结果并没有任何参数)
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
{
return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
} /// <summary>
///执行的SqlCommand (没有返回结果)
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
}
} /// <summary>
/// 执行存储过程通过的SqlCommand (没有返回结果)
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="spName">存储过程名称</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名");
if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (返回结果并没有任何参数)。
/// </summary>
/// <param name="connection">SqlConnection连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of SqlParameters
return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (返回结果并没有任何参数)
/// </summary>
/// <param name="connection">一个现有的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("没有提供现有的数据库连接");
SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
int retval = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
if (mustCloseConnection)
connection.Close();
return retval;
} /// <summary>
///执行存储过程通过的SqlCommand (没有返回结果)
/// </summary>
/// <param name="connection">一个现有的数据库连接</param>
/// <param name="spName">存储过程名称</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供现有的数据库连接");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程的名字");
if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (没有返回结果并没有任何参数)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>A返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
{
return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (没有返回结果)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("请为提供SqlTransaction提供连接", "transaction");
SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
int retval = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return retval;
} /// <summary>
/// 执行的SqlCommand (没有返回结果)对所提供的SqlTransaction
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("请为提供SqlTransaction提供连接", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("请提供存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, parameterValues); return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteNonQuery #region ExecuteDataset /// <summary>
/// 执行的SqlCommand (即返回一个结果,并没有任何参数)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
{
return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个结果)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("connectionString参数没有提供");
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
return ExecuteDataset(connection, commandType, commandText, commandParameters);
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个结果).
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("connectionString参数没有提供");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个结果,并没有任何参数)
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
{
return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个结果)
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象"); SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
cmd.CommandTimeout = connection.ConnectionTimeout;
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection); using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
da.Fill(ds);
cmd.Parameters.Clear(); if (mustCloseConnection)
connection.Close();
return ds;
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个结果).
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程的名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名");
if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个结果,没有任何参数)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
{
return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个结果)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("没有提供transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction"); SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
da.Fill(ds);
cmd.Parameters.Clear();
return ds;
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个结果)对所提供的SqlTransaction 。.
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回结果集DataSet</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("没有提供transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, parameterValues); return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteDataset #region ExecuteReader /// <summary>
/// 这个枚举用来表是把数据库连接对象交给sqlHelper来处理还是调用者自己进行处理
/// </summary>
private enum SqlConnectionOwnership
{
/// <summary>SqlHelper来处理</summary>
Internal,
/// <summary>调用者自行处理</summary>
External
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果)
/// </summary>
/// <param name="connection">一个有效的SqlConnection </param>
/// <param name="transaction">一个有效的SqlTransaction,可以为null</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <param name="connectionOwnership">sqlHelper来处理还是调用者自己进行处理数据库连接对象</param>
/// <returns>返回一个只读结果</returns>
private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象"); bool mustCloseConnection = true;
SqlCommand cmd = new SqlCommand();
cmd.CommandTimeout = ;
try
{
PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
SqlDataReader dataReader; if (connectionOwnership == SqlConnectionOwnership.External)
{
dataReader = cmd.ExecuteReader();
}
else
{
dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
}
bool canClear = true;
foreach (SqlParameter commandParameter in cmd.Parameters)
{
if (commandParameter.Direction != ParameterDirection.Input)
canClear = false;
}
if (canClear)
{
cmd.Parameters.Clear();
}
return dataReader;
}
catch
{
if (mustCloseConnection)
connection.Close();
throw;
}
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果,没有参数)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
{
return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
SqlConnection connection = null;
try
{
connection = new SqlConnection(connectionString);
connection.Open();
return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal);
}
catch
{
if (connection != null) connection.Close();
throw;
} } /// <summary>
/// 使用存储过程执行SqlCommand (即返回一个只读结果)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); AssignParameterValues(commandParameters, parameterValues); return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果,没有参数)
/// </summary>
/// <param name="connection">一个有效的SqlConnection </param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
{
return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果)
/// </summary>
/// <param name="connection">一个有效的SqlConnection</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
} /// <summary>
/// 使用存储过程执行SqlCommand (即返回一个只读结果)
/// </summary>
/// <param name="connection">一个有效的SqlConnection</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); AssignParameterValues(commandParameters, parameterValues); return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果,没有传入的参数)对所提供的SqlTransaction 。.
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
{
return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个只读结果)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("没有提供transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction"); return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个只读结果)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个只读结果</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("没有提供transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, parameterValues); return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteReader #region ExecuteScalar /// <summary>
/// 执行的SqlCommand (即返回第一行第一列,不带参数)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
{
return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回第一行第一列)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
return ExecuteScalar(connection, commandType, commandText, commandParameters);
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回第一行第一列)
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
///执行的SqlCommand (即返回第一行第一列,不带参数)
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
{
return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 有效的数据库连接
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
SqlCommand cmd = new SqlCommand(); bool mustCloseConnection = true;
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
object retval = cmd.ExecuteScalar(); cmd.Parameters.Clear(); if (mustCloseConnection)
connection.Close(); return retval;
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回第一行第一列)
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); AssignParameterValues(commandParameters, parameterValues);
return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行SqlCommand (即返回第一行第一列,不带参数)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
{
return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行SqlCommand (即返回第一行第一列)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction"); SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
object retval = cmd.ExecuteScalar(); cmd.Parameters.Clear();
return retval;
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回第一行第一列)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回数据库中第一行第一列的数据</returns>
public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, parameterValues);
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteScalar #region ExecuteXmlReader
/// <summary>
/// 执行的SqlCommand (即返回一个XmlReader,并没有任何参数)对所提供的SqlConnection 。
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
{
return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行的SqlCommand (即返回一个XmlReader)对所提供的SqlConnection 。
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象"); bool mustCloseConnection = true;
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
XmlReader retval = cmd.ExecuteXmlReader();
cmd.Parameters.Clear(); return retval;
}
catch
{
if (mustCloseConnection)
connection.Close();
throw;
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个XmlReader)对所提供的SqlConnection 。
/// </summary>
/// <param name="connection">有效的数据库连接</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行SqlCommand (即返回第一行第一列,不带参数)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
{
return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// 执行SqlCommand (即返回第一行第一列)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); XmlReader retval = cmd.ExecuteXmlReader(); cmd.Parameters.Clear();
return retval;
} /// <summary>
/// 使用存储过程执行SqlCommand (即返回第一行第一列)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">一个有效的SqlTransaction</param>
/// <param name="spName">存储过程名</param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回的xmlReader对象</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, parameterValues);
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteXmlReader #region FillDataset
/// <summary>
/// 执行的SqlCommand (即返回一个DataSet,并没有任何参数)
/// </summary>
/// <param name="connectionString">数据库连接对象字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)</param>
public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("缺少数据库连接字符串");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null"); using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
FillDataset(connection, commandType, commandText, dataSet, tableNames);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个DataSet)
/// </summary>
/// <param name="connectionString">数据库连接对象字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
public static void FillDataset(string connectionString, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params SqlParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("缺少数据库连接字符串");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
}
} /// <summary>
/// 使用存储过程执行的SqlCommand (即返回一个DataSet)
/// </summary>
/// <param name="connectionString">数据库连接对象字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void FillDataset(string connectionString, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("缺少数据库连接字符串");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null"); using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open(); FillDataset(connection, spName, dataSet, tableNames, parameterValues);
}
} /// <summary>
/// 执行的SqlCommand (即返回一个DataSet,不带参数)
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
public static void FillDataset(SqlConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames)
{
FillDataset(connection, commandType, commandText, dataSet, tableNames, null);
} /// <summary>
/// 执行的SqlCommand (即返回一个DataSet)
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void FillDataset(SqlConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params SqlParameter[] commandParameters)
{
FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters);
} /// <summary>
/// 执行的SqlCommand (即返回一个DataSet)
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void FillDataset(SqlConnection connection, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, parameterValues);
FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
}
else
{
FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
}
} /// <summary>
/// 执行SqlCommand (即返回一个DataSet,不带参数)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
public static void FillDataset(SqlTransaction transaction, CommandType commandType,
string commandText,
DataSet dataSet, string[] tableNames)
{
FillDataset(transaction, commandType, commandText, dataSet, tableNames, null);
} /// <summary>
/// 执行SqlCommand (即返回一个DataSet)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void FillDataset(SqlTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params SqlParameter[] commandParameters)
{
FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
} /// <summary>
/// 使用存储过程执行SqlCommand (即返回一个DataSet)对所提供的SqlTransaction 。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
public static void FillDataset(SqlTransaction transaction, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); if ((parameterValues != null) && (parameterValues.Length > ))
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
AssignParameterValues(commandParameters, parameterValues); FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
}
else
{
FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
}
} /// <summary>
/// 私有方法,执行的SqlCommand (即返回一个结果集)对指定的SqlTransaction和SqlConnection使用提供的参数。
/// </summary>
/// <param name="connection">数据库连接对象</param>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)
/// </param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params SqlParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
if (dataSet == null) throw new ArgumentNullException("dataSet不能为null"); SqlCommand command = new SqlCommand();
bool mustCloseConnection = true;
PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command))
{ if (tableNames != null && tableNames.Length > )
{
string tableName = "Table";
for (int index = ; index < tableNames.Length; index++)
{
if (tableNames[index] == null || tableNames[index].Length == ) throw new ArgumentException("该tableNames参数必须包含一个表格中的字段,这里提供了一个值为空或空字符串.", "tableNames");
dataAdapter.TableMappings.Add(tableName, tableNames[index]);
tableName += (index + ).ToString();
}
} dataAdapter.Fill(dataSet);
command.Parameters.Clear();
} if (mustCloseConnection)
connection.Close();
}
#endregion #region UpdateDataset
/// <summary>
/// 执行各自的命令为每个插入,更新或删除的行中的数据。
/// </summary> /// <param name="insertCommand">插入的SqlCommand</param>
/// <param name="deleteCommand">删除的SqlCommand</param>
/// <param name="updateCommand">更新的SqlCommand</param>
/// <param name="dataSet">一个DataSet ,其中将载有结果</param>
/// <param name="tableName">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)</param>
public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName)
{
if (insertCommand == null) throw new ArgumentNullException("没有提供插入的SqlCommand");
if (deleteCommand == null) throw new ArgumentNullException("没有提供删除的SqlCommand");
if (updateCommand == null) throw new ArgumentNullException("没有提供更新的SqlCommand");
if (tableName == null || tableName.Length == ) throw new ArgumentNullException("没有提供tableName"); using (SqlDataAdapter dataAdapter = new SqlDataAdapter())
{
dataAdapter.UpdateCommand = updateCommand;
dataAdapter.InsertCommand = insertCommand;
dataAdapter.DeleteCommand = deleteCommand; dataAdapter.Update(dataSet, tableName); dataSet.AcceptChanges();
}
}
#endregion #region CreateCommand
/// <summary>
/// 简化建立一个SQL命令对象,允许存储过程和可选的参数
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程</param>
/// <param name="sourceColumns">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称(可能是实际的表名称)</param>
/// <returns>sql命令对象</returns>
public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("存储过程名"); SqlCommand cmd = new SqlCommand(spName, connection);
cmd.CommandType = CommandType.StoredProcedure; if ((sourceColumns != null) && (sourceColumns.Length > ))
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); for (int index = ; index < sourceColumns.Length; index++)
commandParameters[index].SourceColumn = sourceColumns[index]; AttachParameters(cmd, commandParameters);
} return cmd;
}
#endregion #region ExecuteNonQueryTypedParams
/// <summary>
/// 执行存储过程通过的SqlCommand (没有返回结果)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程</param>
/// <param name="dataRow">储存参数值的DataRow.</param>
/// <returns>返回更新的行数</returns>
public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程名"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行存储过程通过的SqlCommand (没有返回结果)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程</param>
/// <param name="dataRow">储存参数值的DataRow.</param>
/// <returns>返回更新的行数</returns>
public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行存储过程通过的SqlCommand (没有返回结果)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回更新的行数</returns>
public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion #region ExecuteDatasetTypedParams
/// <summary>
///执行预存程序通过的SqlCommand (返回DataSet)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集Dataset</returns>
public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回DataSet)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集Dataset</returns>
public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回DataSet)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集Dataset</returns>
public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
}
} #endregion #region ExecuteReaderTypedParams
/// <summary>
/// 执行预存程序通过的SqlCommand (返回SqlDataReader)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集SqlDataReader</returns>
public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回SqlDataReader)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集SqlDataReader</returns>
public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回SqlDataReader)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回结果集SqlDataReader</returns>
public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象.", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion #region ExecuteScalarTypedParams
/// <summary>
/// 执行预存程序通过的SqlCommand (返回第一行第一列)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回第一行第一列</returns>
public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == ) throw new ArgumentNullException("没有提供数据库连接字符串");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回第一行第一列)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow</param>
/// <returns>返回第一行第一列</returns>
public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回第一行第一列)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow.</param>
/// <returns>返回第一行第一列</returns>
public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion #region ExecuteXmlReaderTypedParams
/// <summary>
/// 执行预存程序通过的SqlCommand (返回XmlReader)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="connection">有效的SqlConnection对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow.</param>
/// <returns>返回XmlReader</returns>
public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{
SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// 执行预存程序通过的SqlCommand (返回XmlReader)使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库,发现参数的存储过程(第一次每一个存储过程被称为) ,并指定值的基础上连续值。
/// </summary>
/// <param name="transaction">有效的SqlTransaction对象</param>
/// <param name="spName">存储过程名</param>
/// <param name="dataRow">储存参数值的DataRow.</param>
/// <returns>返回XmlReader</returns>
public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象.", "transaction");
if (spName == null || spName.Length == ) throw new ArgumentNullException("没有提供存储过程"); if (dataRow != null && dataRow.ItemArray.Length > )
{ SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
AssignParameterValues(commandParameters, dataRow); return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion /// <summary>
/// 执行多条SQL语句,实现数据库事务。
/// </summary>
/// <param name="connectionString">多条SQL语句</param>
/// <param name="SQLStringList">多条SQL语句</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlTran(string connectionString, List<String> SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
int count = ;
for (int n = ; n < SQLStringList.Count; n++)
{
string strsql = SQLStringList[n];
if (strsql.Trim().Length > )
{
cmd.CommandText = strsql;
count += cmd.ExecuteNonQuery();
}
}
tx.Commit();
return count;
}
catch
{
tx.Rollback();
return ;
}
}
} /// <summary>
/// 执行多条SQL语句,实现数据库事务。
/// </summary>
/// <param name="connectionString">泛型列</param>
/// <param name="SQLStringList">泛型列</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlTran(string connectionString, List<CommandInfo> cmdList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.Transaction = trans;
int count = ;
//循环
foreach (CommandInfo myDE in cmdList)
{
cmd.Parameters.Clear();
cmd.CommandText = myDE.CommandText;
cmd.CommandType = myDE.CommandType;
AttachParameters(cmd, myDE.Parameters);
try
{
int result = cmd.ExecuteNonQuery();
count += result;
}
catch
{
trans.Rollback();
return ;
}
}
trans.Commit();
return count; }
}
} /// <summary>
/// 执行多条SQL语句,实现数据库事务。
/// </summary>
/// <param name="connectionString">泛型列</param>
/// <param name="SQLStringList">泛型列</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlTranWithException(string connectionString, List<CommandInfo> cmdList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.Transaction = trans;
int count = ;
//循环
foreach (CommandInfo myDE in cmdList)
{
cmd.Parameters.Clear();
cmd.CommandText = myDE.CommandText;
cmd.CommandType = myDE.CommandType;
AttachParameters(cmd, myDE.Parameters);
try
{
int result = cmd.ExecuteNonQuery();
count += result;
}
catch (Exception ex)
{
trans.Rollback();
throw;
}
}
trans.Commit();
return count; }
}
} ///<summary>
///直接通过DataSet更新数据库表
///</summary>
///<param name="ds"></param>
///<param name="strTblName">ds中要更新的表名</param>
///<param name="strConnection"></param>
///<returns></returns>
public static int UpdateByDataSet(DataSet ds, string strTblName, string strConnection)
{ SqlConnection conn = new SqlConnection(strConnection); SqlDataAdapter myAdapter = new SqlDataAdapter();
SqlCommand myCommand = new SqlCommand("select * from " + strTblName, conn);
myAdapter.SelectCommand = myCommand;
SqlCommandBuilder myCommandBuilder = new SqlCommandBuilder(myAdapter);
return myAdapter.Update(ds, strTblName);
} /// <summary>
/// 判断reader里是否存在列名
/// </summary>
/// <param name="reader"></param>
/// <param name="name"></param>
/// <returns></returns>
public static bool ContainsField(IDataReader reader, string name)
{
for (int i = ; i < reader.FieldCount; i++)
{
if (reader.GetName(i) == name)
return true;
} return false;
} }
public class CommandInfo
{
private string _commandText;
private CommandType _commandType; public CommandType CommandType
{
get { return _commandType; }
set { _commandType = value; }
}
public string CommandText
{
get { return _commandText; }
set { _commandText = value; }
}
private SqlParameter[] _parameters; public SqlParameter[] Parameters
{
get { return _parameters; }
set { _parameters = value; }
} public CommandInfo(string sqlText, SqlParameter[] para, CommandType ct)
{
_commandText = sqlText;
_parameters = para;
_commandType = ct;
}
}

C# 数据操作工具类的更多相关文章

  1. 【手撸一个ORM】第十步、数据操作工具类 MyDb

    说明 其实就是数据库操作的一些封装,很久不用SqlCommand操作数据库了,看了点园子里的文章就直接上手写了,功能上没问题,但写法上是否完美高效无法保证,建议有需要的朋友自己重写,当然如果能把最佳实 ...

  2. [转载]C# FTP操作工具类

    本文转载自<C# Ftp操作工具类>,仅对原文格式进行了整理. 介绍了几种FTP操作的函数,供后期编程时查阅. 参考一: using System; using System.Collec ...

  3. DataTable操作工具类DataTableHelper

    DataTable操作工具类DataTableHelper. 功能介绍: 将泛型集合填充为数据表 将泛型填充为数据表 将对象集合填充为数据表 将对象填充为数据表 将定IDictionary数据转换为D ...

  4. 【转载】ASP.NET工具类:文件夹目录Directory操作工具类

    在ASP.NET开发网站的过程中,有时候会涉及到文件夹相关操作,如判断文件夹目录是否存在.删除文件夹目录.创建文件.删除文件.复制文件夹等等.这一批有关文件目录的操作可以通过Directory类.Fi ...

  5. Hbase 操作工具类

    依赖jar <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-cli ...

  6. java并发学习--第四章 JDK提供的线程原子性操作工具类

    在了解JDK提供的线程原子性操作工具类之前,我们应该先知道什么是原子性:在多线程并发的条件下,对于变量的操作是线程安全的,不会受到其他线程的干扰.接下来我们就学习JDK中线程的原子性操作. 一.CAS ...

  7. C#-ade.net-实体类、数据访问类

    实体类.数据访问类 是由封装演变而来,使对数据的访问更便捷,使用时只需要调用即可,无需再次编写代码 实体类是按照数据库表的结构封装起来的一个类 首先,新建文件夹 App_Code ,用于存放数据库类等 ...

  8. 我的DbHelper数据操作类

    其实,微软的企业库中有一个非常不错的数据操作类了.但是,不少公司(起码我遇到的几个...),对一些"封装"了些什么的东西不太敢用,虽然我推荐过微软的企业库框架了...但是还是要&q ...

  9. ado.net 实体类_数据访问类

    实体类: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ...

随机推荐

  1. freemarker中的round、floor和ceiling数字的舍入处理

    freemarker中的round.floor和ceiling数字的舍入处理 1.简易说明 (1)round:四舍五入 (2)floor:向下取整 (3)ceiling:向上取整 2.举例说明 < ...

  2. 使用Visual Studio创建简单的自己定义Web Part 部件属性

    使用Visual Studio创建简单的自己定义Web Part 部件属性 自己定义属性使用额外的选项和设置拓展你的Web part部件.本文主要解说怎样使用Visual Studio创建简单的自己定 ...

  3. Linux文件系统的几个性能测试软件小结

    曾经测试Linux系统下的分布式集群系统的性能,使用了一些测试软件,公司让我给部门同事做一次基础培训,于是翻看以前所写的记录资料挑选了其中几个,所记之处并不完全,只记录使用的功能. 1.Iozone ...

  4. ubuntu搭建LAMP服务器

    新手记录下...... 安装apache apt-get install apache2 安装mysql apt-get install mysql-server 安装php apt-get inst ...

  5. 代码片段 - Golang 实现集合操作

    ------------------------------------------------------------ 如果用于多例程,可以使用下面的版本: -------------------- ...

  6. C# 程序集反射

    namespace AssemblyLibrary { public class AssemblyLibrary { public static object LoadAssembly(string ...

  7. L - Fabled Rooks(中途相遇法和贪心)

    Problem F: Fabled Rooks We would like to place n rooks, 1 ≤ n ≤ 5000, on a n×n board subject to the ...

  8. Quadtrees--四叉树

    Description A quadtree is a representation format used to encode images. The fundamental idea behind ...

  9. Windows OpenVPN Client and tls-auth

    The official Windows OpenVPN client does not seem to work properly with the tls-auth option if a key ...

  10. 《MFC游戏开发》笔记五 定时器和简单动画

    本系列文章由七十一雾央编写,转载请注明出处. http://blog.csdn.net/u011371356/article/details/9332377 作者:七十一雾央 新浪微博:http:// ...