标签：rpe 删除 getc format 技术 sqlt parameter values 增删改
1 public static class SqlHelper 2 { 3 private static readonly string conStr = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString; 4 5 //执行增删改的 6 public static int ExecuteNonQuery(string sql, CommandType cmdType, params SqlParameter[] pms) 7 { 8 using (SqlConnection con = new SqlConnection(conStr)) 9 { 10 using (SqlCommand cmd = new SqlCommand(sql, con)) 11 { 12 cmd.CommandType = cmdType; 13 if (pms != null) 14 { 15 cmd.Parameters.AddRange(pms); 16 } 17 con.Open(); 18 return cmd.ExecuteNonQuery(); 19 } 20 } 21 } 22 23 //封装一个执行返回单个值的方法 24 public static object ExecuteScalar(string sql, CommandType cmdType, params SqlParameter[] pms) 25 { 26 using (SqlConnection con = new SqlConnection(conStr)) 27 { 28 using (SqlCommand cmd = new SqlCommand(sql, con)) 29 { 30 cmd.CommandType = cmdType; 31 if (pms != null) 32 { 33 cmd.Parameters.AddRange(pms); 34 } 35 con.Open(); 36 return cmd.ExecuteScalar(); 37 } 38 } 39 } 40 41 //返回SqlDataReader对象的方法 42 43 public static SqlDataReader ExecuteReader(string sql, CommandType cmdType, params SqlParameter[] pms) 44 { 45 SqlConnection con = new SqlConnection(conStr); 46 using (SqlCommand cmd = new SqlCommand(sql, con)) 47 { 48 cmd.CommandType = cmdType; 49 if (pms != null) 50 { 51 cmd.Parameters.AddRange(pms); 52 } 53 try 54 { 55 con.Open(); 56 //这里第二个参数代表在函数外部，如果掉了close()方法，则con会随之一起销毁 57 return cmd.ExecuteReader(CommandBehavior.CloseConnection); 58 } 59 catch (Exception) 60 { 61 con.Close(); 62 con.Dispose(); 63 throw; 64 } 65 } 66 } 67 68 69 //封装一个返回DataTable的方法 70 public static DataTable ExecuteDataTable(string sql, CommandType cmdType, params SqlParameter[] pms) 71 { 72 DataTable dt = new DataTable(); 73 using (SqlDataAdapter adapter = new SqlDataAdapter(sql, conStr)) 74 { 75 adapter.SelectCommand.CommandType = cmdType; 76 if (pms != null) 77 { 78 adapter.SelectCommand.Parameters.AddRange(pms); 79 } 80 adapter.Fill(dt); 81 } 82 83 return dt; 84 } 85 }
1 using System; 2 using System.Collections; 3 using System.Collections.Generic; 4 using System.Configuration; 5 using System.Data; 6 using System.Data.SqlClient; 7 using System.Linq; 8 using System.Text; 9 using System.Threading.Tasks; 10 using System.Xml; 11 12 namespace ConsoleApplication1 13 { 14 /// <summary> 15 /// SqlServer数据访问帮助类 16 /// </summary> 17 public sealed class SqlHelper 18 { 19 #region 私有构造函数和方法 20 21 private SqlHelper() { } 22 23 /// <summary> 24 /// 将SqlParameter参数数组(参数值)分配给SqlCommand命令. 25 /// 这个方法将给任何一个参数分配DBNull.Value; 26 /// 该操作将阻止默认值的使用. 27 /// </summary> 28 /// <param name="command">命令名</param> 29 /// <param name="commandParameters">SqlParameters数组</param> 30 private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters) 31 { 32 if (command == null) throw new ArgumentNullException("command"); 33 if (commandParameters != null) 34 { 35 foreach (SqlParameter p in commandParameters) 36 { 37 if (p != null) 38 { 39 // 检查未分配值的输出参数,将其分配以DBNull.Value. 40 if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) && 41 (p.Value == null)) 42 { 43 p.Value = DBNull.Value; 44 } 45 command.Parameters.Add(p); 46 } 47 } 48 } 49 } 50 51 /// <summary> 52 /// 将DataRow类型的列值分配到SqlParameter参数数组. 53 /// </summary> 54 /// <param name="commandParameters">要分配值的SqlParameter参数数组</param> 55 /// <param name="dataRow">将要分配给存储过程参数的DataRow</param> 56 private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow) 57 { 58 if ((commandParameters == null) || (dataRow == null)) 59 { 60 return; 61 } 62 63 int i = 0; 64 // 设置参数值 65 foreach (SqlParameter commandParameter in commandParameters) 66 { 67 // 创建参数名称,如果不存在,只抛出一个异常. 68 if (commandParameter.ParameterName == null || 69 commandParameter.ParameterName.Length <= 1) 70 throw new Exception( 71 string.Format("请提供参数{0}一个有效的名称{1}.", i, commandParameter.ParameterName)); 72 // 从dataRow的表中获取为参数数组中数组名称的列的索引. 73 // 如果存在和参数名称相同的列,则将列值赋给当前名称的参数. 74 if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1) 75 commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)]; 76 i++; 77 } 78 } 79 80 /// <summary> 81 /// 将一个对象数组分配给SqlParameter参数数组. 82 /// </summary> 83 /// <param name="commandParameters">要分配值的SqlParameter参数数组</param> 84 /// <param name="parameterValues">将要分配给存储过程参数的对象数组</param> 85 private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues) 86 { 87 if ((commandParameters == null) || (parameterValues == null)) 88 { 89 return; 90 } 91 92 // 确保对象数组个数与参数个数匹配,如果不匹配,抛出一个异常. 93 if (commandParameters.Length != parameterValues.Length) 94 { 95 throw new ArgumentException("参数值个数与参数不匹配."); 96 } 97 98 // 给参数赋值 99 for (int i = 0, j = commandParameters.Length; i < j; i++) 100 { 101 // If the current array value derives from IDbDataParameter, then assign its Value property 102 if (parameterValues[i] is IDbDataParameter) 103 { 104 IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i]; 105 if (paramInstance.Value == null) 106 { 107 commandParameters[i].Value = DBNull.Value; 108 } 109 else 110 { 111 commandParameters[i].Value = paramInstance.Value; 112 } 113 } 114 else if (parameterValues[i] == null) 115 { 116 commandParameters[i].Value = DBNull.Value; 117 } 118 else 119 { 120 commandParameters[i].Value = parameterValues[i]; 121 } 122 } 123 } 124 125 /// <summary> 126 /// 预处理用户提供的命令,数据库连接/事务/命令类型/参数 127 /// </summary> 128 /// <param name="command">要处理的SqlCommand</param> 129 /// <param name="connection">数据库连接</param> 130 /// <param name="transaction">一个有效的事务或者是null值</param> 131 /// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param> 132 /// <param name="commandText">存储过程名或都T-SQL命令文本</param> 133 /// <param name="commandParameters">和命令相关联的SqlParameter参数数组,如果没有参数为‘null‘</param> 134 /// <param name="mustCloseConnection"><c>true</c> 如果连接是打开的,则为true,其它情况下为false.</param> 135 private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection) 136 { 137 if (command == null) throw new ArgumentNullException("command"); 138 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText"); 139 140 // If the provided connection is not open, we will open it 141 if (connection.State != ConnectionState.Open) 142 { 143 mustCloseConnection = true; 144 connection.Open(); 145 } 146 else 147 { 148 mustCloseConnection = false; 149 } 150 151 // 给命令分配一个数据库连接. 152 command.Connection = connection; 153 154 // 设置命令文本(存储过程名或SQL语句) 155 command.CommandText = commandText; 156 157 // 分配事务 158 if (transaction != null) 159 { 160 if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 161 command.Transaction = transaction; 162 } 163 164 // 设置命令类型. 165 command.CommandType = commandType; 166 167 // 分配命令参数 168 if (commandParameters != null) 169 { 170 AttachParameters(command, commandParameters); 171 } 172 return; 173 } 174 175 #endregion 私有构造函数和方法结束 176 177 #region 数据库连接 178 /// <summary> 179 /// 一个有效的数据库连接字符串 180 /// </summary> 181 /// <returns></returns> 182 public static string GetConnSting() 183 { 184 return ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString; 185 } 186 /// <summary> 187 /// 一个有效的数据库连接对象 188 /// </summary> 189 /// <returns></returns> 190 public static SqlConnection GetConnection() 191 { 192 SqlConnection Connection = new SqlConnection(SqlHelper.GetConnSting()); 193 return Connection; 194 } 195 #endregion 196 197 #region ExecuteNonQuery命令 198 199 /// <summary> 200 /// 执行指定连接字符串,类型的SqlCommand. 201 /// </summary> 202 /// <remarks> 203 /// 示例: 204 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders"); 205 /// </remarks> 206 /// <param name="connectionString">一个有效的数据库连接字符串</param> 207 /// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param> 208 /// <param name="commandText">存储过程名称或SQL语句</param> 209 /// <returns>返回命令影响的行数</returns> 210 public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText) 211 { 212 return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null); 213 } 214 215 /// <summary> 216 /// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果. 217 /// </summary> 218 /// <remarks> 219 /// 示例: 220 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); 221 /// </remarks> 222 /// <param name="connectionString">一个有效的数据库连接字符串</param> 223 /// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param> 224 /// <param name="commandText">存储过程名称或SQL语句</param> 225 /// <param name="commandParameters">SqlParameter参数数组</param> 226 /// <returns>返回命令影响的行数</returns> 227 public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 228 { 229 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 230 231 using (SqlConnection connection = new SqlConnection(connectionString)) 232 { 233 connection.Open(); 234 235 return ExecuteNonQuery(connection, commandType, commandText, commandParameters); 236 } 237 } 238 239 /// <summary> 240 /// 执行指定连接字符串的存储过程,将对象数组的值赋给存储过程参数, 241 /// 此方法需要在参数缓存方法中探索参数并生成参数. 242 /// </summary> 243 /// <remarks> 244 /// 这个方法没有提供访问输出参数和返回值. 245 /// 示例: 246 /// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36); 247 /// </remarks> 248 /// <param name="connectionString">一个有效的数据库连接字符串/param> 249 /// <param name="spName">存储过程名称</param> 250 /// <param name="parameterValues">分配到存储过程输入参数的对象数组</param> 251 /// <returns>返回受影响的行数</returns> 252 public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues) 253 { 254 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 255 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 256 257 // 如果存在参数值 258 if ((parameterValues != null) && (parameterValues.Length > 0)) 259 { 260 // 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组. 261 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 262 263 // 给存储过程参数赋值 264 AssignParameterValues(commandParameters, parameterValues); 265 266 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters); 267 } 268 else 269 { 270 // 没有参数情况下 271 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName); 272 } 273 } 274 275 /// <summary> 276 /// 执行指定数据库连接对象的命令 277 /// </summary> 278 /// <remarks> 279 /// 示例: 280 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders"); 281 /// </remarks> 282 /// <param name="connection">一个有效的数据库连接对象</param> 283 /// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> 284 /// <param name="commandText">存储过程名称或T-SQL语句</param> 285 /// <returns>返回影响的行数</returns> 286 public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText) 287 { 288 return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null); 289 } 290 291 /// <summary> 292 /// 执行指定数据库连接对象的命令 293 /// </summary> 294 /// <remarks> 295 /// 示例: 296 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); 297 /// </remarks> 298 /// <param name="connection">一个有效的数据库连接对象</param> 299 /// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> 300 /// <param name="commandText">T存储过程名称或T-SQL语句</param> 301 /// <param name="commandParameters">SqlParamter参数数组</param> 302 /// <returns>返回影响的行数</returns> 303 public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 304 { 305 if (connection == null) throw new ArgumentNullException("connection"); 306 307 // 创建SqlCommand命令,并进行预处理 308 SqlCommand cmd = new SqlCommand(); 309 bool mustCloseConnection = false; 310 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection); 311 312 // Finally, execute the command 313 int retval = cmd.ExecuteNonQuery(); 314 315 // 清除参数,以便再次使用. 316 cmd.Parameters.Clear(); 317 if (mustCloseConnection) 318 connection.Close(); 319 return retval; 320 } 321 322 /// <summary> 323 /// 执行指定数据库连接对象的命令,将对象数组的值赋给存储过程参数. 324 /// </summary> 325 /// <remarks> 326 /// 此方法不提供访问存储过程输出参数和返回值 327 /// 示例: 328 /// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36); 329 /// </remarks> 330 /// <param name="connection">一个有效的数据库连接对象</param> 331 /// <param name="spName">存储过程名</param> 332 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 333 /// <returns>返回影响的行数</returns> 334 public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues) 335 { 336 if (connection == null) throw new ArgumentNullException("connection"); 337 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 338 339 // 如果有参数值 340 if ((parameterValues != null) && (parameterValues.Length > 0)) 341 { 342 // 从缓存中加载存储过程参数 343 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 344 345 // 给存储过程分配参数值 346 AssignParameterValues(commandParameters, parameterValues); 347 348 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters); 349 } 350 else 351 { 352 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName); 353 } 354 } 355 356 /// <summary> 357 /// 执行带事务的SqlCommand. 358 /// </summary> 359 /// <remarks> 360 /// 示例.: 361 /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders"); 362 /// </remarks> 363 /// <param name="transaction">一个有效的数据库连接对象</param> 364 /// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> 365 /// <param name="commandText">存储过程名称或T-SQL语句</param> 366 /// <returns>返回影响的行数/returns> 367 public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText) 368 { 369 return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null); 370 } 371 372 /// <summary> 373 /// 执行带事务的SqlCommand(指定参数). 374 /// </summary> 375 /// <remarks> 376 /// 示例: 377 /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 378 /// </remarks> 379 /// <param name="transaction">一个有效的数据库连接对象</param> 380 /// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> 381 /// <param name="commandText">存储过程名称或T-SQL语句</param> 382 /// <param name="commandParameters">SqlParamter参数数组</param> 383 /// <returns>返回影响的行数</returns> 384 public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 385 { 386 if (transaction == null) throw new ArgumentNullException("transaction"); 387 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 388 389 // 预处理 390 SqlCommand cmd = new SqlCommand(); 391 bool mustCloseConnection = false; 392 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 393 394 // 执行 395 int retval = cmd.ExecuteNonQuery(); 396 397 // 清除参数集,以便再次使用. 398 cmd.Parameters.Clear(); 399 return retval; 400 } 401 402 /// <summary> 403 /// 执行带事务的SqlCommand(指定参数值). 404 /// </summary> 405 /// <remarks> 406 /// 此方法不提供访问存储过程输出参数和返回值 407 /// 示例: 408 /// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36); 409 /// </remarks> 410 /// <param name="transaction">一个有效的数据库连接对象</param> 411 /// <param name="spName">存储过程名</param> 412 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 413 /// <returns>返回受影响的行数</returns> 414 public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues) 415 { 416 if (transaction == null) throw new ArgumentNullException("transaction"); 417 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 418 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 419 420 // 如果有参数值 421 if ((parameterValues != null) && (parameterValues.Length > 0)) 422 { 423 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 424 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 425 426 // 给存储过程参数赋值 427 AssignParameterValues(commandParameters, parameterValues); 428 429 // 调用重载方法 430 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters); 431 } 432 else 433 { 434 // 没有参数值 435 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName); 436 } 437 } 438 439 #endregion ExecuteNonQuery方法结束 440 441 #region ExecuteDataset方法 442 443 /// <summary> 444 /// 执行指定数据库连接字符串的命令,返回DataSet. 445 /// </summary> 446 /// <remarks> 447 /// 示例: 448 /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders"); 449 /// </remarks> 450 /// <param name="connectionString">一个有效的数据库连接字符串</param> 451 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 452 /// <param name="commandText">存储过程名称或T-SQL语句</param> 453 /// <returns>返回一个包含结果集的DataSet</returns> 454 public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText) 455 { 456 return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null); 457 } 458 459 /// <summary> 460 /// 执行指定数据库连接字符串的命令,返回DataSet. 461 /// </summary> 462 /// <remarks> 463 /// 示例: 464 /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 465 /// </remarks> 466 /// <param name="connectionString">一个有效的数据库连接字符串</param> 467 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 468 /// <param name="commandText">存储过程名称或T-SQL语句</param> 469 /// <param name="commandParameters">SqlParamters参数数组</param> 470 /// <returns>返回一个包含结果集的DataSet</returns> 471 public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 472 { 473 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 474 475 // 创建并打开数据库连接对象,操作完成释放对象. 476 using (SqlConnection connection = new SqlConnection(connectionString)) 477 { 478 connection.Open(); 479 480 // 调用指定数据库连接字符串重载方法. 481 return ExecuteDataset(connection, commandType, commandText, commandParameters); 482 } 483 } 484 485 /// <summary> 486 /// 执行指定数据库连接字符串的命令,直接提供参数值,返回DataSet. 487 /// </summary> 488 /// <remarks> 489 /// 此方法不提供访问存储过程输出参数和返回值. 490 /// 示例: 491 /// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36); 492 /// </remarks> 493 /// <param name="connectionString">一个有效的数据库连接字符串</param> 494 /// <param name="spName">存储过程名</param> 495 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 496 /// <returns>返回一个包含结果集的DataSet</returns> 497 public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues) 498 { 499 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 500 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 501 502 if ((parameterValues != null) && (parameterValues.Length > 0)) 503 { 504 // 从缓存中检索存储过程参数 505 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 506 507 // 给存储过程参数分配值 508 AssignParameterValues(commandParameters, parameterValues); 509 510 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters); 511 } 512 else 513 { 514 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName); 515 } 516 } 517 518 /// <summary> 519 /// 执行指定数据库连接对象的命令,返回DataSet. 520 /// </summary> 521 /// <remarks> 522 /// 示例: 523 /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders"); 524 /// </remarks> 525 /// <param name="connection">一个有效的数据库连接对象</param> 526 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 527 /// <param name="commandText">存储过程名或T-SQL语句</param> 528 /// <returns>返回一个包含结果集的DataSet</returns> 529 public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText) 530 { 531 return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null); 532 } 533 534 /// <summary> 535 /// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet. 536 /// </summary> 537 /// <remarks> 538 /// 示例: 539 /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 540 /// </remarks> 541 /// <param name="connection">一个有效的数据库连接对象</param> 542 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 543 /// <param name="commandText">存储过程名或T-SQL语句</param> 544 /// <param name="commandParameters">SqlParamter参数数组</param> 545 /// <returns>返回一个包含结果集的DataSet</returns> 546 public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 547 { 548 if (connection == null) throw new ArgumentNullException("connection"); 549 550 // 预处理 551 SqlCommand cmd = new SqlCommand(); 552 bool mustCloseConnection = false; 553 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection); 554 555 // 创建SqlDataAdapter和DataSet. 556 using (SqlDataAdapter da = new SqlDataAdapter(cmd)) 557 { 558 DataSet ds = new DataSet(); 559 560 // 填充DataSet. 561 da.Fill(ds); 562 563 cmd.Parameters.Clear(); 564 565 if (mustCloseConnection) 566 connection.Close(); 567 568 return ds; 569 } 570 } 571 572 /// <summary> 573 /// 执行指定数据库连接对象的命令,指定参数值,返回DataSet. 574 /// </summary> 575 /// <remarks> 576 /// 此方法不提供访问存储过程输入参数和返回值. 577 /// 示例.: 578 /// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36); 579 /// </remarks> 580 /// <param name="connection">一个有效的数据库连接对象</param> 581 /// <param name="spName">存储过程名</param> 582 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 583 /// <returns>返回一个包含结果集的DataSet</returns> 584 public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues) 585 { 586 if (connection == null) throw new ArgumentNullException("connection"); 587 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 588 589 if ((parameterValues != null) && (parameterValues.Length > 0)) 590 { 591 // 比缓存中加载存储过程参数 592 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 593 594 // 给存储过程参数分配值 595 AssignParameterValues(commandParameters, parameterValues); 596 597 return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters); 598 } 599 else 600 { 601 return ExecuteDataset(connection, CommandType.StoredProcedure, spName); 602 } 603 } 604 605 /// <summary> 606 /// 执行指定事务的命令,返回DataSet. 607 /// </summary> 608 /// <remarks> 609 /// 示例: 610 /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders"); 611 /// </remarks> 612 /// <param name="transaction">事务</param> 613 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 614 /// <param name="commandText">存储过程名或T-SQL语句</param> 615 /// <returns>返回一个包含结果集的DataSet</returns> 616 public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText) 617 { 618 return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null); 619 } 620 621 /// <summary> 622 /// 执行指定事务的命令,指定参数,返回DataSet. 623 /// </summary> 624 /// <remarks> 625 /// 示例: 626 /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 627 /// </remarks> 628 /// <param name="transaction">事务</param> 629 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 630 /// <param name="commandText">存储过程名或T-SQL语句</param> 631 /// <param name="commandParameters">SqlParamter参数数组</param> 632 /// <returns>返回一个包含结果集的DataSet</returns> 633 public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 634 { 635 if (transaction == null) throw new ArgumentNullException("transaction"); 636 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 637 638 // 预处理 639 SqlCommand cmd = new SqlCommand(); 640 bool mustCloseConnection = false; 641 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 642 643 // 创建 DataAdapter & DataSet 644 using (SqlDataAdapter da = new SqlDataAdapter(cmd)) 645 { 646 DataSet ds = new DataSet(); 647 da.Fill(ds); 648 cmd.Parameters.Clear(); 649 return ds; 650 } 651 } 652 653 /// <summary> 654 /// 执行指定事务的命令,指定参数值,返回DataSet. 655 /// </summary> 656 /// <remarks> 657 /// 此方法不提供访问存储过程输入参数和返回值. 658 /// 示例.: 659 /// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36); 660 /// </remarks> 661 /// <param name="transaction">事务</param> 662 /// <param name="spName">存储过程名</param> 663 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 664 /// <returns>返回一个包含结果集的DataSet</returns> 665 public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues) 666 { 667 if (transaction == null) throw new ArgumentNullException("transaction"); 668 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 669 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 670 671 if ((parameterValues != null) && (parameterValues.Length > 0)) 672 { 673 // 从缓存中加载存储过程参数 674 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 675 676 // 给存储过程参数分配值 677 AssignParameterValues(commandParameters, parameterValues); 678 679 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters); 680 } 681 else 682 { 683 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName); 684 } 685 } 686 687 #endregion ExecuteDataset数据集命令结束 688 689 #region ExecuteReader 数据阅读器 690 691 /// <summary> 692 /// 枚举,标识数据库连接是由SqlHelper提供还是由调用者提供 693 /// </summary> 694 private enum SqlConnectionOwnership 695 { 696 /// <summary>由SqlHelper提供连接</summary> 697 Internal, 698 /// <summary>由调用者提供连接</summary> 699 External 700 } 701 702 /// <summary> 703 /// 执行指定数据库连接对象的数据阅读器. 704 /// </summary> 705 /// <remarks> 706 /// 如果是SqlHelper打开连接,当连接关闭DataReader也将关闭. 707 /// 如果是调用都打开连接,DataReader由调用都管理. 708 /// </remarks> 709 /// <param name="connection">一个有效的数据库连接对象</param> 710 /// <param name="transaction">一个有效的事务,或者为 ‘null‘</param> 711 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 712 /// <param name="commandText">存储过程名或T-SQL语句</param> 713 /// <param name="commandParameters">SqlParameters参数数组,如果没有参数则为‘null‘</param> 714 /// <param name="connectionOwnership">标识数据库连接对象是由调用者提供还是由SqlHelper提供</param> 715 /// <returns>返回包含结果集的SqlDataReader</returns> 716 private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership) 717 { 718 if (connection == null) throw new ArgumentNullException("connection"); 719 720 bool mustCloseConnection = false; 721 // 创建命令 722 SqlCommand cmd = new SqlCommand(); 723 try 724 { 725 PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 726 727 // 创建数据阅读器 728 SqlDataReader dataReader; 729 730 if (connectionOwnership == SqlConnectionOwnership.External) 731 { 732 dataReader = cmd.ExecuteReader(); 733 } 734 else 735 { 736 dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection); 737 } 738 739 // 清除参数,以便再次使用.. 740 // HACK: There is a problem here, the output parameter values are fletched 741 // when the reader is closed, so if the parameters are detached from the command 742 // then the SqlReader can磘 set its values. 743 // When this happen, the parameters can磘 be used again in other command. 744 bool canClear = true; 745 foreach (SqlParameter commandParameter in cmd.Parameters) 746 { 747 if (commandParameter.Direction != ParameterDirection.Input) 748 canClear = false; 749 } 750 751 if (canClear) 752 { 753 cmd.Parameters.Clear(); 754 } 755 756 return dataReader; 757 } 758 catch 759 { 760 if (mustCloseConnection) 761 connection.Close(); 762 throw; 763 } 764 } 765 766 /// <summary> 767 /// 执行指定数据库连接字符串的数据阅读器. 768 /// </summary> 769 /// <remarks> 770 /// 示例: 771 /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders"); 772 /// </remarks> 773 /// <param name="connectionString">一个有效的数据库连接字符串</param> 774 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 775 /// <param name="commandText">存储过程名或T-SQL语句</param> 776 /// <returns>返回包含结果集的SqlDataReader</returns> 777 public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText) 778 { 779 return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null); 780 } 781 782 /// <summary> 783 /// 执行指定数据库连接字符串的数据阅读器,指定参数. 784 /// </summary> 785 /// <remarks> 786 /// 示例: 787 /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 788 /// </remarks> 789 /// <param name="connectionString">一个有效的数据库连接字符串</param> 790 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 791 /// <param name="commandText">存储过程名或T-SQL语句</param> 792 /// <param name="commandParameters">SqlParamter参数数组(new SqlParameter("@prodid", 24))</param> 793 /// <returns>返回包含结果集的SqlDataReader</returns> 794 public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 795 { 796 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 797 SqlConnection connection = null; 798 try 799 { 800 connection = new SqlConnection(connectionString); 801 connection.Open(); 802 803 return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal); 804 } 805 catch 806 { 807 // If we fail to return the SqlDatReader, we need to close the connection ourselves 808 if (connection != null) connection.Close(); 809 throw; 810 } 811 812 } 813 814 /// <summary> 815 /// 执行指定数据库连接字符串的数据阅读器,指定参数值. 816 /// </summary> 817 /// <remarks> 818 /// 此方法不提供访问存储过程输出参数和返回值参数. 819 /// 示例: 820 /// SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36); 821 /// </remarks> 822 /// <param name="connectionString">一个有效的数据库连接字符串</param> 823 /// <param name="spName">存储过程名</param> 824 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 825 /// <returns>返回包含结果集的SqlDataReader</returns> 826 public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues) 827 { 828 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 829 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 830 831 if ((parameterValues != null) && (parameterValues.Length > 0)) 832 { 833 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 834 835 AssignParameterValues(commandParameters, parameterValues); 836 837 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters); 838 } 839 else 840 { 841 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName); 842 } 843 } 844 845 /// <summary> 846 /// 执行指定数据库连接对象的数据阅读器. 847 /// </summary> 848 /// <remarks> 849 /// 示例: 850 /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders"); 851 /// </remarks> 852 /// <param name="connection">一个有效的数据库连接对象</param> 853 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 854 /// <param name="commandText">存储过程名或T-SQL语句</param> 855 /// <returns>返回包含结果集的SqlDataReader</returns> 856 public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText) 857 { 858 return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null); 859 } 860 861 /// <summary> 862 /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数. 863 /// </summary> 864 /// <remarks> 865 /// 示例: 866 /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 867 /// </remarks> 868 /// <param name="connection">一个有效的数据库连接对象</param> 869 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 870 /// <param name="commandText">命令类型 (存储过程,命令文本或其它)</param> 871 /// <param name="commandParameters">SqlParamter参数数组</param> 872 /// <returns>返回包含结果集的SqlDataReader</returns> 873 public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 874 { 875 return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External); 876 } 877 878 /// <summary> 879 /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数值. 880 /// </summary> 881 /// <remarks> 882 /// 此方法不提供访问存储过程输出参数和返回值参数. 883 /// 示例: 884 /// SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36); 885 /// </remarks> 886 /// <param name="connection">一个有效的数据库连接对象</param> 887 /// <param name="spName">T存储过程名</param> 888 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 889 /// <returns>返回包含结果集的SqlDataReader</returns> 890 public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues) 891 { 892 if (connection == null) throw new ArgumentNullException("connection"); 893 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 894 895 if ((parameterValues != null) && (parameterValues.Length > 0)) 896 { 897 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 898 899 AssignParameterValues(commandParameters, parameterValues); 900 901 return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters); 902 } 903 else 904 { 905 return ExecuteReader(connection, CommandType.StoredProcedure, spName); 906 } 907 } 908 909 /// <summary> 910 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值. 911 /// </summary> 912 /// <remarks> 913 /// 示例: 914 /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders"); 915 /// </remarks> 916 /// <param name="transaction">一个有效的连接事务</param> 917 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 918 /// <param name="commandText">存储过程名称或T-SQL语句</param> 919 /// <returns>返回包含结果集的SqlDataReader</returns> 920 public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText) 921 { 922 return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null); 923 } 924 925 /// <summary> 926 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数. 927 /// </summary> 928 /// <remarks> 929 /// 示例: 930 /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 931 /// </remarks> 932 /// <param name="transaction">一个有效的连接事务</param> 933 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 934 /// <param name="commandText">存储过程名称或T-SQL语句</param> 935 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 936 /// <returns>返回包含结果集的SqlDataReader</returns> 937 public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 938 { 939 if (transaction == null) throw new ArgumentNullException("transaction"); 940 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 941 942 return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External); 943 } 944 945 /// <summary> 946 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值. 947 /// </summary> 948 /// <remarks> 949 /// 此方法不提供访问存储过程输出参数和返回值参数. 950 /// 951 /// 示例: 952 /// SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36); 953 /// </remarks> 954 /// <param name="transaction">一个有效的连接事务</param> 955 /// <param name="spName">存储过程名称</param> 956 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 957 /// <returns>返回包含结果集的SqlDataReader</returns> 958 public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues) 959 { 960 if (transaction == null) throw new ArgumentNullException("transaction"); 961 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 962 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 963 964 // 如果有参数值 965 if ((parameterValues != null) && (parameterValues.Length > 0)) 966 { 967 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 968 969 AssignParameterValues(commandParameters, parameterValues); 970 971 return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 972 } 973 else 974 { 975 // 没有参数值 976 return ExecuteReader(transaction, CommandType.StoredProcedure, spName); 977 } 978 } 979 980 #endregion ExecuteReader数据阅读器 981 982 #region ExecuteScalar 返回结果集中的第一行第一列 983 984 /// <summary> 985 /// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列. 986 /// </summary> 987 /// <remarks> 988 /// 示例: 989 /// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount"); 990 /// </remarks> 991 /// <param name="connectionString">一个有效的数据库连接字符串</param> 992 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 993 /// <param name="commandText">存储过程名称或T-SQL语句</param> 994 /// <returns>返回结果集中的第一行第一列</returns> 995 public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText) 996 { 997 // 执行参数为空的方法 998 return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null); 999 } 1000 1001 /// <summary> 1002 /// 执行指定数据库连接字符串的命令,指定参数,返回结果集中的第一行第一列. 1003 /// </summary> 1004 /// <remarks> 1005 /// 示例: 1006 /// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 1007 /// </remarks> 1008 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1009 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1010 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1011 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1012 /// <returns>返回结果集中的第一行第一列</returns> 1013 public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 1014 { 1015 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1016 // 创建并打开数据库连接对象,操作完成释放对象. 1017 using (SqlConnection connection = new SqlConnection(connectionString)) 1018 { 1019 connection.Open(); 1020 1021 // 调用指定数据库连接字符串重载方法. 1022 return ExecuteScalar(connection, commandType, commandText, commandParameters); 1023 } 1024 } 1025 1026 /// <summary> 1027 /// 执行指定数据库连接字符串的命令,指定参数值,返回结果集中的第一行第一列. 1028 /// </summary> 1029 /// <remarks> 1030 /// 此方法不提供访问存储过程输出参数和返回值参数. 1031 /// 1032 /// 示例: 1033 /// int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36); 1034 /// </remarks> 1035 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1036 /// <param name="spName">存储过程名称</param> 1037 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1038 /// <returns>返回结果集中的第一行第一列</returns> 1039 public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues) 1040 { 1041 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1042 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1043 1044 // 如果有参数值 1045 if ((parameterValues != null) && (parameterValues.Length > 0)) 1046 { 1047 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1048 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 1049 1050 // 给存储过程参数赋值 1051 AssignParameterValues(commandParameters, parameterValues); 1052 1053 // 调用重载方法 1054 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters); 1055 } 1056 else 1057 { 1058 // 没有参数值 1059 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName); 1060 } 1061 } 1062 1063 /// <summary> 1064 /// 执行指定数据库连接对象的命令,返回结果集中的第一行第一列. 1065 /// </summary> 1066 /// <remarks> 1067 /// 示例: 1068 /// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount"); 1069 /// </remarks> 1070 /// <param name="connection">一个有效的数据库连接对象</param> 1071 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1072 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1073 /// <returns>返回结果集中的第一行第一列</returns> 1074 public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText) 1075 { 1076 // 执行参数为空的方法 1077 return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null); 1078 } 1079 1080 /// <summary> 1081 /// 执行指定数据库连接对象的命令,指定参数,返回结果集中的第一行第一列. 1082 /// </summary> 1083 /// <remarks> 1084 /// 示例: 1085 /// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 1086 /// </remarks> 1087 /// <param name="connection">一个有效的数据库连接对象</param> 1088 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1089 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1090 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1091 /// <returns>返回结果集中的第一行第一列</returns> 1092 public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 1093 { 1094 if (connection == null) throw new ArgumentNullException("connection"); 1095 1096 // 创建SqlCommand命令,并进行预处理 1097 SqlCommand cmd = new SqlCommand(); 1098 1099 bool mustCloseConnection = false; 1100 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection); 1101 1102 // 执行SqlCommand命令,并返回结果. 1103 object retval = cmd.ExecuteScalar(); 1104 1105 // 清除参数,以便再次使用. 1106 cmd.Parameters.Clear(); 1107 1108 if (mustCloseConnection) 1109 connection.Close(); 1110 1111 return retval; 1112 } 1113 1114 /// <summary> 1115 /// 执行指定数据库连接对象的命令,指定参数值,返回结果集中的第一行第一列. 1116 /// </summary> 1117 /// <remarks> 1118 /// 此方法不提供访问存储过程输出参数和返回值参数. 1119 /// 1120 /// 示例: 1121 /// int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36); 1122 /// </remarks> 1123 /// <param name="connection">一个有效的数据库连接对象</param> 1124 /// <param name="spName">存储过程名称</param> 1125 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1126 /// <returns>返回结果集中的第一行第一列</returns> 1127 public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues) 1128 { 1129 if (connection == null) throw new ArgumentNullException("connection"); 1130 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1131 1132 // 如果有参数值 1133 if ((parameterValues != null) && (parameterValues.Length > 0)) 1134 { 1135 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1136 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1137 1138 // 给存储过程参数赋值 1139 AssignParameterValues(commandParameters, parameterValues); 1140 1141 // 调用重载方法 1142 return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters); 1143 } 1144 else 1145 { 1146 // 没有参数值 1147 return ExecuteScalar(connection, CommandType.StoredProcedure, spName); 1148 } 1149 } 1150 1151 /// <summary> 1152 /// 执行指定数据库事务的命令,返回结果集中的第一行第一列. 1153 /// </summary> 1154 /// <remarks> 1155 /// 示例: 1156 /// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount"); 1157 /// </remarks> 1158 /// <param name="transaction">一个有效的连接事务</param> 1159 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1160 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1161 /// <returns>返回结果集中的第一行第一列</returns> 1162 public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText) 1163 { 1164 // 执行参数为空的方法 1165 return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null); 1166 } 1167 1168 /// <summary> 1169 /// 执行指定数据库事务的命令,指定参数,返回结果集中的第一行第一列. 1170 /// </summary> 1171 /// <remarks> 1172 /// 示例: 1173 /// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 1174 /// </remarks> 1175 /// <param name="transaction">一个有效的连接事务</param> 1176 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1177 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1178 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1179 /// <returns>返回结果集中的第一行第一列</returns> 1180 public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 1181 { 1182 if (transaction == null) throw new ArgumentNullException("transaction"); 1183 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1184 1185 // 创建SqlCommand命令,并进行预处理 1186 SqlCommand cmd = new SqlCommand(); 1187 bool mustCloseConnection = false; 1188 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 1189 1190 // 执行SqlCommand命令,并返回结果. 1191 object retval = cmd.ExecuteScalar(); 1192 1193 // 清除参数,以便再次使用. 1194 cmd.Parameters.Clear(); 1195 return retval; 1196 } 1197 1198 /// <summary> 1199 /// 执行指定数据库事务的命令,指定参数值,返回结果集中的第一行第一列. 1200 /// </summary> 1201 /// <remarks> 1202 /// 此方法不提供访问存储过程输出参数和返回值参数. 1203 /// 1204 /// 示例: 1205 /// int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36); 1206 /// </remarks> 1207 /// <param name="transaction">一个有效的连接事务</param> 1208 /// <param name="spName">存储过程名称</param> 1209 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1210 /// <returns>返回结果集中的第一行第一列</returns> 1211 public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues) 1212 { 1213 if (transaction == null) throw new ArgumentNullException("transaction"); 1214 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1215 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1216 1217 // 如果有参数值 1218 if ((parameterValues != null) && (parameterValues.Length > 0)) 1219 { 1220 // PPull the parameters for this stored procedure from the parameter cache () 1221 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 1222 1223 // 给存储过程参数赋值 1224 AssignParameterValues(commandParameters, parameterValues); 1225 1226 // 调用重载方法 1227 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters); 1228 } 1229 else 1230 { 1231 // 没有参数值 1232 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName); 1233 } 1234 } 1235 1236 #endregion ExecuteScalar 1237 1238 #region ExecuteXmlReader XML阅读器 1239 /// <summary> 1240 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回. 1241 /// </summary> 1242 /// <remarks> 1243 /// 示例: 1244 /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders"); 1245 /// </remarks> 1246 /// <param name="connection">一个有效的数据库连接对象</param> 1247 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1248 /// <param name="commandText">存储过程名称或T-SQL语句 using "FOR XML AUTO"</param> 1249 /// <returns>返回XmlReader结果集对象.</returns> 1250 public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText) 1251 { 1252 // 执行参数为空的方法 1253 return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null); 1254 } 1255 1256 /// <summary> 1257 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数. 1258 /// </summary> 1259 /// <remarks> 1260 /// 示例: 1261 /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 1262 /// </remarks> 1263 /// <param name="connection">一个有效的数据库连接对象</param> 1264 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1265 /// <param name="commandText">存储过程名称或T-SQL语句 using "FOR XML AUTO"</param> 1266 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1267 /// <returns>返回XmlReader结果集对象.</returns> 1268 public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 1269 { 1270 if (connection == null) throw new ArgumentNullException("connection"); 1271 1272 bool mustCloseConnection = false; 1273 // 创建SqlCommand命令,并进行预处理 1274 SqlCommand cmd = new SqlCommand(); 1275 try 1276 { 1277 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection); 1278 1279 // 执行命令 1280 XmlReader retval = cmd.ExecuteXmlReader(); 1281 1282 // 清除参数,以便再次使用. 1283 cmd.Parameters.Clear(); 1284 1285 return retval; 1286 } 1287 catch 1288 { 1289 if (mustCloseConnection) 1290 connection.Close(); 1291 throw; 1292 } 1293 } 1294 1295 /// <summary> 1296 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值. 1297 /// </summary> 1298 /// <remarks> 1299 /// 此方法不提供访问存储过程输出参数和返回值参数. 1300 /// 1301 /// 示例: 1302 /// XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36); 1303 /// </remarks> 1304 /// <param name="connection">一个有效的数据库连接对象</param> 1305 /// <param name="spName">存储过程名称 using "FOR XML AUTO"</param> 1306 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1307 /// <returns>返回XmlReader结果集对象.</returns> 1308 public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues) 1309 { 1310 if (connection == null) throw new ArgumentNullException("connection"); 1311 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1312 1313 // 如果有参数值 1314 if ((parameterValues != null) && (parameterValues.Length > 0)) 1315 { 1316 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1317 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1318 1319 // 给存储过程参数赋值 1320 AssignParameterValues(commandParameters, parameterValues); 1321 1322 // 调用重载方法 1323 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters); 1324 } 1325 else 1326 { 1327 // 没有参数值 1328 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName); 1329 } 1330 } 1331 1332 /// <summary> 1333 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回. 1334 /// </summary> 1335 /// <remarks> 1336 /// 示例: 1337 /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders"); 1338 /// </remarks> 1339 /// <param name="transaction">一个有效的连接事务</param> 1340 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1341 /// <param name="commandText">存储过程名称或T-SQL语句 using "FOR XML AUTO"</param> 1342 /// <returns>返回XmlReader结果集对象.</returns> 1343 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText) 1344 { 1345 // 执行参数为空的方法 1346 return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null); 1347 } 1348 1349 /// <summary> 1350 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数. 1351 /// </summary> 1352 /// <remarks> 1353 /// 示例: 1354 /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 1355 /// </remarks> 1356 /// <param name="transaction">一个有效的连接事务</param> 1357 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1358 /// <param name="commandText">存储过程名称或T-SQL语句 using "FOR XML AUTO"</param> 1359 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1360 /// <returns>返回XmlReader结果集对象.</returns> 1361 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 1362 { 1363 if (transaction == null) throw new ArgumentNullException("transaction"); 1364 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1365 1366 // 创建SqlCommand命令,并进行预处理 1367 SqlCommand cmd = new SqlCommand(); 1368 bool mustCloseConnection = false; 1369 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 1370 1371 // 执行命令 1372 XmlReader retval = cmd.ExecuteXmlReader(); 1373 1374 // 清除参数,以便再次使用. 1375 cmd.Parameters.Clear(); 1376 return retval; 1377 } 1378 1379 /// <summary> 1380 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值. 1381 /// </summary> 1382 /// <remarks> 1383 /// 此方法不提供访问存储过程输出参数和返回值参数. 1384 /// 1385 /// 示例: 1386 /// XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36); 1387 /// </remarks> 1388 /// <param name="transaction">一个有效的连接事务</param> 1389 /// <param name="spName">存储过程名称</param> 1390 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1391 /// <returns>返回一个包含结果集的DataSet.</returns> 1392 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues) 1393 { 1394 if (transaction == null) throw new ArgumentNullException("transaction"); 1395 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1396 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1397 1398 // 如果有参数值 1399 if ((parameterValues != null) && (parameterValues.Length > 0)) 1400 { 1401 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1402 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 1403 1404 // 给存储过程参数赋值 1405 AssignParameterValues(commandParameters, parameterValues); 1406 1407 // 调用重载方法 1408 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 1409 } 1410 else 1411 { 1412 // 没有参数值 1413 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName); 1414 } 1415 } 1416 1417 #endregion ExecuteXmlReader 阅读器结束 1418 1419 #region FillDataset 填充数据集 1420 /// <summary> 1421 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集. 1422 /// </summary> 1423 /// <remarks> 1424 /// 示例: 1425 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 1426 /// </remarks> 1427 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1428 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1429 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1430 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1431 /// <param name="tableNames">表映射的数据表数组 1432 /// 用户定义的表名 (可有是实际的表名.)</param> 1433 public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames) 1434 { 1435 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1436 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1437 1438 // 创建并打开数据库连接对象,操作完成释放对象. 1439 using (SqlConnection connection = new SqlConnection(connectionString)) 1440 { 1441 connection.Open(); 1442 1443 // 调用指定数据库连接字符串重载方法. 1444 FillDataset(connection, commandType, commandText, dataSet, tableNames); 1445 } 1446 } 1447 1448 /// <summary> 1449 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.指定命令参数. 1450 /// </summary> 1451 /// <remarks> 1452 /// 示例: 1453 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 1454 /// </remarks> 1455 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1456 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1457 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1458 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1459 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1460 /// <param name="tableNames">表映射的数据表数组 1461 /// 用户定义的表名 (可有是实际的表名.) 1462 /// </param> 1463 public static void FillDataset(string connectionString, CommandType commandType, 1464 string commandText, DataSet dataSet, string[] tableNames, 1465 params SqlParameter[] commandParameters) 1466 { 1467 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1468 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1469 // 创建并打开数据库连接对象,操作完成释放对象. 1470 using (SqlConnection connection = new SqlConnection(connectionString)) 1471 { 1472 connection.Open(); 1473 1474 // 调用指定数据库连接字符串重载方法. 1475 FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters); 1476 } 1477 } 1478 1479 /// <summary> 1480 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集,指定存储过程参数值. 1481 /// </summary> 1482 /// <remarks> 1483 /// 此方法不提供访问存储过程输出参数和返回值参数. 1484 /// 1485 /// 示例: 1486 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24); 1487 /// </remarks> 1488 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1489 /// <param name="spName">存储过程名称</param> 1490 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1491 /// <param name="tableNames">表映射的数据表数组 1492 /// 用户定义的表名 (可有是实际的表名.) 1493 /// </param> 1494 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1495 public static void FillDataset(string connectionString, string spName, 1496 DataSet dataSet, string[] tableNames, 1497 params object[] parameterValues) 1498 { 1499 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1500 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1501 // 创建并打开数据库连接对象,操作完成释放对象. 1502 using (SqlConnection connection = new SqlConnection(connectionString)) 1503 { 1504 connection.Open(); 1505 1506 // 调用指定数据库连接字符串重载方法. 1507 FillDataset(connection, spName, dataSet, tableNames, parameterValues); 1508 } 1509 } 1510 1511 /// <summary> 1512 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集. 1513 /// </summary> 1514 /// <remarks> 1515 /// 示例: 1516 /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 1517 /// </remarks> 1518 /// <param name="connection">一个有效的数据库连接对象</param> 1519 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1520 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1521 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1522 /// <param name="tableNames">表映射的数据表数组 1523 /// 用户定义的表名 (可有是实际的表名.) 1524 /// </param> 1525 public static void FillDataset(SqlConnection connection, CommandType commandType, 1526 string commandText, DataSet dataSet, string[] tableNames) 1527 { 1528 FillDataset(connection, commandType, commandText, dataSet, tableNames, null); 1529 } 1530 1531 /// <summary> 1532 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定参数. 1533 /// </summary> 1534 /// <remarks> 1535 /// 示例: 1536 /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 1537 /// </remarks> 1538 /// <param name="connection">一个有效的数据库连接对象</param> 1539 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1540 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1541 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1542 /// <param name="tableNames">表映射的数据表数组 1543 /// 用户定义的表名 (可有是实际的表名.) 1544 /// </param> 1545 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1546 public static void FillDataset(SqlConnection connection, CommandType commandType, 1547 string commandText, DataSet dataSet, string[] tableNames, 1548 params SqlParameter[] commandParameters) 1549 { 1550 FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters); 1551 } 1552 1553 /// <summary> 1554 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定存储过程参数值. 1555 /// </summary> 1556 /// <remarks> 1557 /// 此方法不提供访问存储过程输出参数和返回值参数. 1558 /// 1559 /// 示例: 1560 /// FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36); 1561 /// </remarks> 1562 /// <param name="connection">一个有效的数据库连接对象</param> 1563 /// <param name="spName">存储过程名称</param> 1564 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1565 /// <param name="tableNames">表映射的数据表数组 1566 /// 用户定义的表名 (可有是实际的表名.) 1567 /// </param> 1568 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1569 public static void FillDataset(SqlConnection connection, string spName, 1570 DataSet dataSet, string[] tableNames, 1571 params object[] parameterValues) 1572 { 1573 if (connection == null) throw new ArgumentNullException("connection"); 1574 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1575 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1576 1577 // 如果有参数值 1578 if ((parameterValues != null) && (parameterValues.Length > 0)) 1579 { 1580 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1581 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1582 1583 // 给存储过程参数赋值 1584 AssignParameterValues(commandParameters, parameterValues); 1585 1586 // 调用重载方法 1587 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters); 1588 } 1589 else 1590 { 1591 // 没有参数值 1592 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames); 1593 } 1594 } 1595 1596 /// <summary> 1597 /// 执行指定数据库事务的命令,映射数据表并填充数据集. 1598 /// </summary> 1599 /// <remarks> 1600 /// 示例: 1601 /// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 1602 /// </remarks> 1603 /// <param name="transaction">一个有效的连接事务</param> 1604 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1605 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1606 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1607 /// <param name="tableNames">表映射的数据表数组 1608 /// 用户定义的表名 (可有是实际的表名.) 1609 /// </param> 1610 public static void FillDataset(SqlTransaction transaction, CommandType commandType, 1611 string commandText, 1612 DataSet dataSet, string[] tableNames) 1613 { 1614 FillDataset(transaction, commandType, commandText, dataSet, tableNames, null); 1615 } 1616 1617 /// <summary> 1618 /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定参数. 1619 /// </summary> 1620 /// <remarks> 1621 /// 示例: 1622 /// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 1623 /// </remarks> 1624 /// <param name="transaction">一个有效的连接事务</param> 1625 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1626 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1627 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1628 /// <param name="tableNames">表映射的数据表数组 1629 /// 用户定义的表名 (可有是实际的表名.) 1630 /// </param> 1631 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1632 public static void FillDataset(SqlTransaction transaction, CommandType commandType, 1633 string commandText, DataSet dataSet, string[] tableNames, 1634 params SqlParameter[] commandParameters) 1635 { 1636 FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters); 1637 } 1638 1639 /// <summary> 1640 /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定存储过程参数值. 1641 /// </summary> 1642 /// <remarks> 1643 /// 此方法不提供访问存储过程输出参数和返回值参数. 1644 /// 1645 /// 示例: 1646 /// FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36); 1647 /// </remarks> 1648 /// <param name="transaction">一个有效的连接事务</param> 1649 /// <param name="spName">存储过程名称</param> 1650 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1651 /// <param name="tableNames">表映射的数据表数组 1652 /// 用户定义的表名 (可有是实际的表名.) 1653 /// </param> 1654 /// <param name="parameterValues">分配给存储过程输入参数的对象数组</param> 1655 public static void FillDataset(SqlTransaction transaction, string spName, 1656 DataSet dataSet, string[] tableNames, 1657 params object[] parameterValues) 1658 { 1659 if (transaction == null) throw new ArgumentNullException("transaction"); 1660 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1661 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1662 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1663 1664 // 如果有参数值 1665 if ((parameterValues != null) && (parameterValues.Length > 0)) 1666 { 1667 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1668 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 1669 1670 // 给存储过程参数赋值 1671 AssignParameterValues(commandParameters, parameterValues); 1672 1673 // 调用重载方法 1674 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters); 1675 } 1676 else 1677 { 1678 // 没有参数值 1679 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames); 1680 } 1681 } 1682 1683 /// <summary> 1684 /// [私有方法][内部调用]执行指定数据库连接对象/事务的命令,映射数据表并填充数据集,DataSet/TableNames/SqlParameters. 1685 /// </summary> 1686 /// <remarks> 1687 /// 示例: 1688 /// FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 1689 /// </remarks> 1690 /// <param name="connection">一个有效的数据库连接对象</param> 1691 /// <param name="transaction">一个有效的连接事务</param> 1692 /// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param> 1693 /// <param name="commandText">存储过程名称或T-SQL语句</param> 1694 /// <param name="dataSet">要填充结果集的DataSet实例</param> 1695 /// <param name="tableNames">表映射的数据表数组 1696 /// 用户定义的表名 (可有是实际的表名.) 1697 /// </param> 1698 /// <param name="commandParameters">分配给命令的SqlParamter参数数组</param> 1699 private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType, 1700 string commandText, DataSet dataSet, string[] tableNames, 1701 params SqlParameter[] commandParameters) 1702 { 1703 if (connection == null) throw new ArgumentNullException("connection"); 1704 if (dataSet == null) throw new ArgumentNullException("dataSet"); 1705 1706 // 创建SqlCommand命令,并进行预处理 1707 SqlCommand command = new SqlCommand(); 1708 bool mustCloseConnection = false; 1709 PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection); 1710 1711 // 执行命令 1712 using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command)) 1713 { 1714 1715 // 追加表映射 1716 if (tableNames != null && tableNames.Length > 0) 1717 { 1718 string tableName = "Table"; 1719 for (int index = 0; index < tableNames.Length; index++) 1720 { 1721 if (tableNames[index] == null || tableNames[index].Length == 0) throw new ArgumentException("The tableNames parameter must contain a list of tables, a value was provided as null or empty string.", "tableNames"); 1722 dataAdapter.TableMappings.Add(tableName, tableNames[index]); 1723 tableName += (index + 1).ToString(); 1724 } 1725 } 1726 1727 // 填充数据集使用默认表名称 1728 dataAdapter.Fill(dataSet); 1729 1730 // 清除参数,以便再次使用. 1731 command.Parameters.Clear(); 1732 } 1733 1734 if (mustCloseConnection) 1735 connection.Close(); 1736 } 1737 #endregion 1738 1739 #region UpdateDataset 更新数据集 1740 /// <summary> 1741 /// 执行数据集更新到数据库,指定inserted, updated, or deleted命令. 1742 /// </summary> 1743 /// <remarks> 1744 /// 示例: 1745 /// UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order"); 1746 /// </remarks> 1747 /// <param name="insertCommand">[追加记录]一个有效的T-SQL语句或存储过程</param> 1748 /// <param name="deleteCommand">[删除记录]一个有效的T-SQL语句或存储过程</param> 1749 /// <param name="updateCommand">[更新记录]一个有效的T-SQL语句或存储过程</param> 1750 /// <param name="dataSet">要更新到数据库的DataSet</param> 1751 /// <param name="tableName">要更新到数据库的DataTable</param> 1752 public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName) 1753 { 1754 if (insertCommand == null) throw new ArgumentNullException("insertCommand"); 1755 if (deleteCommand == null) throw new ArgumentNullException("deleteCommand"); 1756 if (updateCommand == null) throw new ArgumentNullException("updateCommand"); 1757 if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName"); 1758 1759 // 创建SqlDataAdapter,当操作完成后释放. 1760 using (SqlDataAdapter dataAdapter = new SqlDataAdapter()) 1761 { 1762 // 设置数据适配器命令 1763 dataAdapter.UpdateCommand = updateCommand; 1764 dataAdapter.InsertCommand = insertCommand; 1765 dataAdapter.DeleteCommand = deleteCommand; 1766 1767 // 更新数据集改变到数据库 1768 dataAdapter.Update(dataSet, tableName); 1769 1770 // 提交所有改变到数据集. 1771 dataSet.AcceptChanges(); 1772 } 1773 } 1774 #endregion 1775 1776 #region CreateCommand 创建一条SqlCommand命令 1777 /// <summary> 1778 /// 创建SqlCommand命令,指定数据库连接对象,存储过程名和参数. 1779 /// </summary> 1780 /// <remarks> 1781 /// 示例: 1782 /// SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName"); 1783 /// </remarks> 1784 /// <param name="connection">一个有效的数据库连接对象</param> 1785 /// <param name="spName">存储过程名称</param> 1786 /// <param name="sourceColumns">源表的列名称数组</param> 1787 /// <returns>返回SqlCommand命令</returns> 1788 public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns) 1789 { 1790 if (connection == null) throw new ArgumentNullException("connection"); 1791 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1792 1793 // 创建命令 1794 SqlCommand cmd = new SqlCommand(spName, connection); 1795 cmd.CommandType = CommandType.StoredProcedure; 1796 1797 // 如果有参数值 1798 if ((sourceColumns != null) && (sourceColumns.Length > 0)) 1799 { 1800 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1801 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1802 1803 // 将源表的列到映射到DataSet命令中. 1804 for (int index = 0; index < sourceColumns.Length; index++) 1805 commandParameters[index].SourceColumn = sourceColumns[index]; 1806 1807 // Attach the discovered parameters to the SqlCommand object 1808 AttachParameters(cmd, commandParameters); 1809 } 1810 1811 return cmd; 1812 } 1813 #endregion 1814 1815 #region ExecuteNonQueryTypedParams 类型化参数(DataRow) 1816 /// <summary> 1817 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回受影响的行数. 1818 /// </summary> 1819 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1820 /// <param name="spName">存储过程名称</param> 1821 /// <param name="dataRow">使用DataRow作为参数值</param> 1822 /// <returns>返回影响的行数</returns> 1823 public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow) 1824 { 1825 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1826 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1827 1828 // 如果row有值,存储过程必须初始化. 1829 if (dataRow != null && dataRow.ItemArray.Length > 0) 1830 { 1831 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1832 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 1833 1834 // 分配参数值 1835 AssignParameterValues(commandParameters, dataRow); 1836 1837 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters); 1838 } 1839 else 1840 { 1841 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName); 1842 } 1843 } 1844 1845 /// <summary> 1846 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回受影响的行数. 1847 /// </summary> 1848 /// <param name="connection">一个有效的数据库连接对象</param> 1849 /// <param name="spName">存储过程名称</param> 1850 /// <param name="dataRow">使用DataRow作为参数值</param> 1851 /// <returns>返回影响的行数</returns> 1852 public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow) 1853 { 1854 if (connection == null) throw new ArgumentNullException("connection"); 1855 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1856 1857 // 如果row有值,存储过程必须初始化. 1858 if (dataRow != null && dataRow.ItemArray.Length > 0) 1859 { 1860 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1861 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1862 1863 // 分配参数值 1864 AssignParameterValues(commandParameters, dataRow); 1865 1866 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters); 1867 } 1868 else 1869 { 1870 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName); 1871 } 1872 } 1873 1874 /// <summary> 1875 /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回受影响的行数. 1876 /// </summary> 1877 /// <param name="transaction">一个有效的连接事务 object</param> 1878 /// <param name="spName">存储过程名称</param> 1879 /// <param name="dataRow">使用DataRow作为参数值</param> 1880 /// <returns>返回影响的行数</returns> 1881 public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 1882 { 1883 if (transaction == null) throw new ArgumentNullException("transaction"); 1884 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1885 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1886 1887 // Sf the row has values, the store procedure parameters must be initialized 1888 if (dataRow != null && dataRow.ItemArray.Length > 0) 1889 { 1890 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1891 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 1892 1893 // 分配参数值 1894 AssignParameterValues(commandParameters, dataRow); 1895 1896 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters); 1897 } 1898 else 1899 { 1900 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName); 1901 } 1902 } 1903 #endregion 1904 1905 #region ExecuteDatasetTypedParams 类型化参数(DataRow) 1906 /// <summary> 1907 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataSet. 1908 /// </summary> 1909 /// <param name="connectionString">一个有效的数据库连接字符串</param> 1910 /// <param name="spName">存储过程名称</param> 1911 /// <param name="dataRow">使用DataRow作为参数值</param> 1912 /// <returns>返回一个包含结果集的DataSet.</returns> 1913 public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow) 1914 { 1915 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 1916 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1917 1918 //如果row有值,存储过程必须初始化. 1919 if (dataRow != null && dataRow.ItemArray.Length > 0) 1920 { 1921 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1922 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 1923 1924 // 分配参数值 1925 AssignParameterValues(commandParameters, dataRow); 1926 1927 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters); 1928 } 1929 else 1930 { 1931 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName); 1932 } 1933 } 1934 1935 /// <summary> 1936 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataSet. 1937 /// </summary> 1938 /// <param name="connection">一个有效的数据库连接对象</param> 1939 /// <param name="spName">存储过程名称</param> 1940 /// <param name="dataRow">使用DataRow作为参数值</param> 1941 /// <returns>返回一个包含结果集的DataSet.</returns> 1942 /// 1943 public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow) 1944 { 1945 if (connection == null) throw new ArgumentNullException("connection"); 1946 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1947 1948 // 如果row有值,存储过程必须初始化. 1949 if (dataRow != null && dataRow.ItemArray.Length > 0) 1950 { 1951 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1952 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 1953 1954 // 分配参数值 1955 AssignParameterValues(commandParameters, dataRow); 1956 1957 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters); 1958 } 1959 else 1960 { 1961 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName); 1962 } 1963 } 1964 1965 /// <summary> 1966 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回DataSet. 1967 /// </summary> 1968 /// <param name="transaction">一个有效的连接事务 object</param> 1969 /// <param name="spName">存储过程名称</param> 1970 /// <param name="dataRow">使用DataRow作为参数值</param> 1971 /// <returns>返回一个包含结果集的DataSet.</returns> 1972 public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 1973 { 1974 if (transaction == null) throw new ArgumentNullException("transaction"); 1975 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 1976 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 1977 1978 // 如果row有值,存储过程必须初始化. 1979 if (dataRow != null && dataRow.ItemArray.Length > 0) 1980 { 1981 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 1982 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 1983 1984 // 分配参数值 1985 AssignParameterValues(commandParameters, dataRow); 1986 1987 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters); 1988 } 1989 else 1990 { 1991 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName); 1992 } 1993 } 1994 1995 #endregion 1996 1997 #region ExecuteReaderTypedParams 类型化参数(DataRow) 1998 /// <summary> 1999 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataReader. 2000 /// </summary> 2001 /// <param name="connectionString">一个有效的数据库连接字符串</param> 2002 /// <param name="spName">存储过程名称</param> 2003 /// <param name="dataRow">使用DataRow作为参数值</param> 2004 /// <returns>返回包含结果集的SqlDataReader</returns> 2005 public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow) 2006 { 2007 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 2008 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2009 2010 // 如果row有值,存储过程必须初始化. 2011 if (dataRow != null && dataRow.ItemArray.Length > 0) 2012 { 2013 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2014 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 2015 2016 // 分配参数值 2017 AssignParameterValues(commandParameters, dataRow); 2018 2019 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters); 2020 } 2021 else 2022 { 2023 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName); 2024 } 2025 } 2026 2027 2028 /// <summary> 2029 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataReader. 2030 /// </summary> 2031 /// <param name="connection">一个有效的数据库连接对象</param> 2032 /// <param name="spName">存储过程名称</param> 2033 /// <param name="dataRow">使用DataRow作为参数值</param> 2034 /// <returns>返回包含结果集的SqlDataReader</returns> 2035 public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow) 2036 { 2037 if (connection == null) throw new ArgumentNullException("connection"); 2038 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2039 2040 // 如果row有值,存储过程必须初始化. 2041 if (dataRow != null && dataRow.ItemArray.Length > 0) 2042 { 2043 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2044 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 2045 2046 // 分配参数值 2047 AssignParameterValues(commandParameters, dataRow); 2048 2049 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters); 2050 } 2051 else 2052 { 2053 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName); 2054 } 2055 } 2056 2057 /// <summary> 2058 /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回DataReader. 2059 /// </summary> 2060 /// <param name="transaction">一个有效的连接事务 object</param> 2061 /// <param name="spName">存储过程名称</param> 2062 /// <param name="dataRow">使用DataRow作为参数值</param> 2063 /// <returns>返回包含结果集的SqlDataReader</returns> 2064 public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 2065 { 2066 if (transaction == null) throw new ArgumentNullException("transaction"); 2067 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 2068 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2069 2070 // 如果row有值,存储过程必须初始化. 2071 if (dataRow != null && dataRow.ItemArray.Length > 0) 2072 { 2073 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2074 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 2075 2076 // 分配参数值 2077 AssignParameterValues(commandParameters, dataRow); 2078 2079 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 2080 } 2081 else 2082 { 2083 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName); 2084 } 2085 } 2086 #endregion 2087 2088 #region ExecuteScalarTypedParams 类型化参数(DataRow) 2089 /// <summary> 2090 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 2091 /// </summary> 2092 /// <param name="connectionString">一个有效的数据库连接字符串</param> 2093 /// <param name="spName">存储过程名称</param> 2094 /// <param name="dataRow">使用DataRow作为参数值</param> 2095 /// <returns>返回结果集中的第一行第一列</returns> 2096 public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow) 2097 { 2098 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 2099 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2100 2101 // 如果row有值,存储过程必须初始化. 2102 if (dataRow != null && dataRow.ItemArray.Length > 0) 2103 { 2104 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2105 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName); 2106 2107 // 分配参数值 2108 AssignParameterValues(commandParameters, dataRow); 2109 2110 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters); 2111 } 2112 else 2113 { 2114 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName); 2115 } 2116 } 2117 2118 /// <summary> 2119 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 2120 /// </summary> 2121 /// <param name="connection">一个有效的数据库连接对象</param> 2122 /// <param name="spName">存储过程名称</param> 2123 /// <param name="dataRow">使用DataRow作为参数值</param> 2124 /// <returns>返回结果集中的第一行第一列</returns> 2125 public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow) 2126 { 2127 if (connection == null) throw new ArgumentNullException("connection"); 2128 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2129 2130 // 如果row有值,存储过程必须初始化. 2131 if (dataRow != null && dataRow.ItemArray.Length > 0) 2132 { 2133 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2134 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 2135 2136 // 分配参数值 2137 AssignParameterValues(commandParameters, dataRow); 2138 2139 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters); 2140 } 2141 else 2142 { 2143 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName); 2144 } 2145 } 2146 2147 /// <summary> 2148 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 2149 /// </summary> 2150 /// <param name="transaction">一个有效的连接事务 object</param> 2151 /// <param name="spName">存储过程名称</param> 2152 /// <param name="dataRow">使用DataRow作为参数值</param> 2153 /// <returns>返回结果集中的第一行第一列</returns> 2154 public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 2155 { 2156 if (transaction == null) throw new ArgumentNullException("transaction"); 2157 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 2158 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2159 2160 // 如果row有值,存储过程必须初始化. 2161 if (dataRow != null && dataRow.ItemArray.Length > 0) 2162 { 2163 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2164 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 2165 2166 // 分配参数值 2167 AssignParameterValues(commandParameters, dataRow); 2168 2169 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters); 2170 } 2171 else 2172 { 2173 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName); 2174 } 2175 } 2176 #endregion 2177 2178 #region ExecuteXmlReaderTypedParams 类型化参数(DataRow) 2179 /// <summary> 2180 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集. 2181 /// </summary> 2182 /// <param name="connection">一个有效的数据库连接对象</param> 2183 /// <param name="spName">存储过程名称</param> 2184 /// <param name="dataRow">使用DataRow作为参数值</param> 2185 /// <returns>返回XmlReader结果集对象.</returns> 2186 public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow) 2187 { 2188 if (connection == null) throw new ArgumentNullException("connection"); 2189 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2190 2191 // 如果row有值,存储过程必须初始化. 2192 if (dataRow != null && dataRow.ItemArray.Length > 0) 2193 { 2194 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2195 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName); 2196 2197 // 分配参数值 2198 AssignParameterValues(commandParameters, dataRow); 2199 2200 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters); 2201 } 2202 else 2203 { 2204 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName); 2205 } 2206 } 2207 2208 /// <summary> 2209 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集. 2210 /// </summary> 2211 /// <param name="transaction">一个有效的连接事务 object</param> 2212 /// <param name="spName">存储过程名称</param> 2213 /// <param name="dataRow">使用DataRow作为参数值</param> 2214 /// <returns>返回XmlReader结果集对象.</returns> 2215 public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 2216 { 2217 if (transaction == null) throw new ArgumentNullException("transaction"); 2218 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 2219 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2220 2221 // 如果row有值,存储过程必须初始化. 2222 if (dataRow != null && dataRow.ItemArray.Length > 0) 2223 { 2224 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 2225 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName); 2226 2227 // 分配参数值 2228 AssignParameterValues(commandParameters, dataRow); 2229 2230 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 2231 } 2232 else 2233 { 2234 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName); 2235 } 2236 } 2237 #endregion 2238 2239 } 2240 2241 /// <summary> 2242 /// SqlHelperParameterCache提供缓存存储过程参数,并能够在运行时从存储过程中探索参数. 2243 /// </summary> 2244 public sealed class SqlHelperParameterCache 2245 { 2246 #region 私有方法,字段,构造函数 2247 // 私有构造函数,妨止类被实例化. 2248 private SqlHelperParameterCache() { } 2249 2250 // 这个方法要注意 2251 private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable()); 2252 2253 /// <summary> 2254 /// 探索运行时的存储过程,返回SqlParameter参数数组. 2255 /// 初始化参数值为 DBNull.Value. 2256 /// </summary> 2257 /// <param name="connection">一个有效的数据库连接</param> 2258 /// <param name="spName">存储过程名称</param> 2259 /// <param name="includeReturnValueParameter">是否包含返回值参数</param> 2260 /// <returns>返回SqlParameter参数数组</returns> 2261 private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter) 2262 { 2263 if (connection == null) throw new ArgumentNullException("connection"); 2264 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2265 2266 SqlCommand cmd = new SqlCommand(spName, connection); 2267 cmd.CommandType = CommandType.StoredProcedure; 2268 2269 connection.Open(); 2270 // 检索cmd指定的存储过程的参数信息,并填充到cmd的Parameters参数集中. 2271 SqlCommandBuilder.DeriveParameters(cmd); 2272 connection.Close(); 2273 // 如果不包含返回值参数,将参数集中的每一个参数删除. 2274 if (!includeReturnValueParameter) 2275 { 2276 cmd.Parameters.RemoveAt(0); 2277 } 2278 2279 // 创建参数数组 2280 SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count]; 2281 // 将cmd的Parameters参数集复制到discoveredParameters数组. 2282 cmd.Parameters.CopyTo(discoveredParameters, 0); 2283 2284 // 初始化参数值为 DBNull.Value. 2285 foreach (SqlParameter discoveredParameter in discoveredParameters) 2286 { 2287 discoveredParameter.Value = DBNull.Value; 2288 } 2289 return discoveredParameters; 2290 } 2291 2292 /// <summary> 2293 /// SqlParameter参数数组的深层拷贝. 2294 /// </summary> 2295 /// <param name="originalParameters">原始参数数组</param> 2296 /// <returns>返回一个同样的参数数组</returns> 2297 private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters) 2298 { 2299 SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length]; 2300 2301 for (int i = 0, j = originalParameters.Length; i < j; i++) 2302 { 2303 clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone(); 2304 } 2305 2306 return clonedParameters; 2307 } 2308 2309 #endregion 私有方法,字段,构造函数结束 2310 2311 #region 缓存方法 2312 2313 /// <summary> 2314 /// 追加参数数组到缓存. 2315 /// </summary> 2316 /// <param name="connectionString">一个有效的数据库连接字符串</param> 2317 /// <param name="commandText">存储过程名或SQL语句</param> 2318 /// <param name="commandParameters">要缓存的参数数组</param> 2319 public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters) 2320 { 2321 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 2322 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText"); 2323 2324 string hashKey = connectionString + ":" + commandText; 2325 2326 paramCache[hashKey] = commandParameters; 2327 } 2328 2329 /// <summary> 2330 /// 从缓存中获取参数数组. 2331 /// </summary> 2332 /// <param name="connectionString">一个有效的数据库连接字符</param> 2333 /// <param name="commandText">存储过程名或SQL语句</param> 2334 /// <returns>参数数组</returns> 2335 public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText) 2336 { 2337 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 2338 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText"); 2339 2340 string hashKey = connectionString + ":" + commandText; 2341 2342 SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[]; 2343 if (cachedParameters == null) 2344 { 2345 return null; 2346 } 2347 else 2348 { 2349 return CloneParameters(cachedParameters); 2350 } 2351 } 2352 2353 #endregion 缓存方法结束 2354 2355 #region 检索指定的存储过程的参数集 2356 2357 /// <summary> 2358 /// 返回指定的存储过程的参数集 2359 /// </summary> 2360 /// <remarks> 2361 /// 这个方法将查询数据库,并将信息存储到缓存. 2362 /// </remarks> 2363 /// <param name="connectionString">一个有效的数据库连接字符</param> 2364 /// <param name="spName">存储过程名</param> 2365 /// <returns>返回SqlParameter参数数组</returns> 2366 public static SqlParameter[] GetSpParameterSet(string connectionString, string spName) 2367 { 2368 return GetSpParameterSet(connectionString, spName, false); 2369 } 2370 2371 /// <summary> 2372 /// 返回指定的存储过程的参数集 2373 /// </summary> 2374 /// <remarks> 2375 /// 这个方法将查询数据库,并将信息存储到缓存. 2376 /// </remarks> 2377 /// <param name="connectionString">一个有效的数据库连接字符.</param> 2378 /// <param name="spName">存储过程名</param> 2379 /// <param name="includeReturnValueParameter">是否包含返回值参数</param> 2380 /// <returns>返回SqlParameter参数数组</returns> 2381 public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter) 2382 { 2383 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 2384 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2385 2386 using (SqlConnection connection = new SqlConnection(connectionString)) 2387 { 2388 return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter); 2389 } 2390 } 2391 2392 /// <summary> 2393 /// [内部]返回指定的存储过程的参数集(使用连接对象). 2394 /// </summary> 2395 /// <remarks> 2396 /// 这个方法将查询数据库,并将信息存储到缓存. 2397 /// </remarks> 2398 /// <param name="connection">一个有效的数据库连接字符</param> 2399 /// <param name="spName">存储过程名</param> 2400 /// <returns>返回SqlParameter参数数组</returns> 2401 internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName) 2402 { 2403 return GetSpParameterSet(connection, spName, false); 2404 } 2405 2406 /// <summary> 2407 /// [内部]返回指定的存储过程的参数集(使用连接对象) 2408 /// </summary> 2409 /// <remarks> 2410 /// 这个方法将查询数据库,并将信息存储到缓存. 2411 /// </remarks> 2412 /// <param name="connection">一个有效的数据库连接对象</param> 2413 /// <param name="spName">存储过程名</param> 2414 /// <param name="includeReturnValueParameter"> 2415 /// 是否包含返回值参数 2416 /// </param> 2417 /// <returns>返回SqlParameter参数数组</returns> 2418 internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter) 2419 { 2420 if (connection == null) throw new ArgumentNullException("connection"); 2421 using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone()) 2422 { 2423 return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter); 2424 } 2425 } 2426 2427 /// <summary> 2428 /// [私有]返回指定的存储过程的参数集(使用连接对象) 2429 /// </summary> 2430 /// <param name="connection">一个有效的数据库连接对象</param> 2431 /// <param name="spName">存储过程名</param> 2432 /// <param name="includeReturnValueParameter">是否包含返回值参数</param> 2433 /// <returns>返回SqlParameter参数数组</returns> 2434 private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter) 2435 { 2436 if (connection == null) throw new ArgumentNullException("connection"); 2437 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName"); 2438 2439 string hashKey = connection.ConnectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : ""); 2440 2441 SqlParameter[] cachedParameters; 2442 2443 cachedParameters = paramCache[hashKey] as SqlParameter[]; 2444 if (cachedParameters == null) 2445 { 2446 SqlParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter); 2447 paramCache[hashKey] = spParameters; 2448 cachedParameters = spParameters; 2449 } 2450 2451 return CloneParameters(cachedParameters); 2452 } 2453 2454 #endregion 参数集检索结束 2455 2456 } 2457 }
标签：rpe 删除 getc format 技术 sqlt parameter values 增删改
原文地址：http://www.cnblogs.com/fnz0/p/7063463.html
