C#操作SQLIte数据。

  1 using System;
  2 using System.Data;
  3 using System.Text.RegularExpressions;
  4 using System.Xml;
  5 using System.IO;
  6 using System.Collections;
  7 using System.Data.SQLite;
  8 
  9 namespace DBUtility.SQLite
 10 {
 11     /// <summary>
 12     /// SQLiteHelper is a utility class similar to "SQLHelper" in MS
 13     /// Data Access Application Block and follows similar pattern.
 14     /// </summary>
 15     public class SQLiteHelper
 16     {
 17         /// <summary>
 18         /// Creates a new <see cref="SQLiteHelper"/> instance. The ctor is marked private since all members are static.
 19         /// </summary>
 20         private SQLiteHelper()
 21         {
 22         }
 23         /// <summary>
 24         /// Creates the command.
 25         /// </summary>
 26         /// <param name="connection">Connection.</param>
 27         /// <param name="commandText">Command text.</param>
 28         /// <param name="commandParameters">Command parameters.</param>
 29         /// <returns>SQLite Command</returns>
 30         public static SQLiteCommand CreateCommand(SQLiteConnection connection, string commandText, params SQLiteParameter[] commandParameters)
 31         {
 32             SQLiteCommand cmd = new SQLiteCommand(commandText, connection);
 33             if (commandParameters.Length > 0)
 34             {
 35                 foreach (SQLiteParameter parm in commandParameters)
 36                     cmd.Parameters.Add(parm);
 37             }
 38             return cmd;
 39         }
 40 
 41         /// <summary>
 42         /// Creates the command.
 43         /// </summary>
 44         /// <param name="connectionString">Connection string.</param>
 45         /// <param name="commandText">Command text.</param>
 46         /// <param name="commandParameters">Command parameters.</param>
 47         /// <returns>SQLite Command</returns>
 48         public static SQLiteCommand CreateCommand(string connectionString, string commandText, params SQLiteParameter[] commandParameters)
 49         {
 50             SQLiteConnection cn = new SQLiteConnection(connectionString);
 51 
 52             SQLiteCommand cmd = new SQLiteCommand(commandText, cn);
 53 
 54             if (commandParameters.Length > 0)
 55             {
 56                 foreach (SQLiteParameter parm in commandParameters)
 57                     cmd.Parameters.Add(parm);
 58             }
 59             return cmd;
 60         }
 61         /// <summary>
 62         /// Creates the parameter.
 63         /// </summary>
 64         /// <param name="parameterName">Name of the parameter.</param>
 65         /// <param name="parameterType">Parameter type.</param>
 66         /// <param name="parameterValue">Parameter value.</param>
 67         /// <returns>SQLiteParameter</returns>
 68         public static SQLiteParameter CreateParameter(string parameterName, System.Data.DbType parameterType, object parameterValue)
 69         {
 70             SQLiteParameter parameter = new SQLiteParameter();
 71             parameter.DbType = parameterType;
 72             parameter.ParameterName = parameterName;
 73             parameter.Value = parameterValue;
 74             return parameter;
 75         }
 76 
 77         /// <summary>
 78         /// Shortcut method to execute dataset from SQL Statement and object[] arrray of parameter values
 79         /// </summary>
 80         /// <param name="connectionString">SQLite Connection string</param>
 81         /// <param name="commandText">SQL Statement with embedded "@param" style parameter names</param>
 82         /// <param name="paramList">object[] array of parameter values</param>
 83         /// <returns></returns>
 84         public static DataSet ExecuteDataSet(string connectionString, string commandText, object[] paramList)
 85         {
 86             SQLiteConnection cn = new SQLiteConnection(connectionString);
 87             SQLiteCommand cmd = cn.CreateCommand();
 88 
 89 
 90             cmd.CommandText = commandText;
 91             if (paramList != null)
 92             {
 93                 AttachParameters(cmd, commandText, paramList);
 94             }
 95             DataSet ds = new DataSet();
 96             if (cn.State == ConnectionState.Closed)
 97                 cn.Open();
 98             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
 99             da.Fill(ds);
100             da.Dispose();
101             cmd.Dispose();
102             cn.Close();
103             return ds;
104         }
105         /// <summary>
106         /// Shortcut method to execute dataset from SQL Statement and object[] arrray of  parameter values
107         /// </summary>
108         /// <param name="cn">Connection.</param>
109         /// <param name="commandText">Command text.</param>
110         /// <param name="paramList">Param list.</param>
111         /// <returns></returns>
112         public static DataSet ExecuteDataSet(SQLiteConnection cn, string commandText, object[] paramList)
113         {
114 
115             SQLiteCommand cmd = cn.CreateCommand();
116 
117 
118             cmd.CommandText = commandText;
119             if (paramList != null)
120             {
121                 AttachParameters(cmd, commandText, paramList);
122             }
123             DataSet ds = new DataSet();
124             if (cn.State == ConnectionState.Closed)
125                 cn.Open();
126             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
127             da.Fill(ds);
128             da.Dispose();
129             cmd.Dispose();
130             cn.Close();
131             return ds;
132         }
133         /// <summary>
134         /// Executes the dataset from a populated Command object.
135         /// </summary>
136         /// <param name="cmd">Fully populated SQLiteCommand</param>
137         /// <returns>DataSet</returns>
138         public static DataSet ExecuteDataset(SQLiteCommand cmd)
139         {
140             if (cmd.Connection.State == ConnectionState.Closed)
141                 cmd.Connection.Open();
142             DataSet ds = new DataSet();
143             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
144             da.Fill(ds);
145             da.Dispose();
146             cmd.Connection.Close();
147             cmd.Dispose();
148             return ds;
149         }
150 
151         /// <summary>
152         /// Executes the dataset in a SQLite Transaction
153         /// </summary>
154         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,  /// and Command, all of which must be created prior to making this method call. </param>
155         /// <param name="commandText">Command text.</param>
156         /// <param name="commandParameters">Sqlite Command parameters.</param>
157         /// <returns>DataSet</returns>
158         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
159         public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, params SQLiteParameter[] commandParameters)
160         {
161 
162             if (transaction == null) throw new ArgumentNullException("transaction");
163             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed, please provide an open transaction.", "transaction");
164             IDbCommand cmd = transaction.Connection.CreateCommand();
165             cmd.CommandText = commandText;
166             foreach (SQLiteParameter parm in commandParameters)
167             {
168                 cmd.Parameters.Add(parm);
169             }
170             if (transaction.Connection.State == ConnectionState.Closed)
171                 transaction.Connection.Open();
172             DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
173             return ds;
174         }
175 
176         /// <summary>
177         /// Executes the dataset with Transaction and object array of parameter values.
178         /// </summary>
179         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,    /// and Command, all of which must be created prior to making this method call. </param>
180         /// <param name="commandText">Command text.</param>
181         /// <param name="commandParameters">object[] array of parameter values.</param>
182         /// <returns>DataSet</returns>
183         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
184         public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, object[] commandParameters)
185         {
186 
187             if (transaction == null) throw new ArgumentNullException("transaction");
188             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,                                                          please provide an open transaction.", "transaction");
189             IDbCommand cmd = transaction.Connection.CreateCommand();
190             cmd.CommandText = commandText;
191             AttachParameters((SQLiteCommand)cmd, cmd.CommandText, commandParameters);
192             if (transaction.Connection.State == ConnectionState.Closed)
193                 transaction.Connection.Open();
194 
195             DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
196             return ds;
197         }
198 
199         #region UpdateDataset
200         /// <summary>
201         /// Executes the respective command for each inserted, updated, or deleted row in the DataSet.
202         /// </summary>
203         /// <remarks>
204         /// e.g.:  
205         ///  UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
206         /// </remarks>
207         /// <param name="insertCommand">A valid SQL statement  to insert new records into the data source</param>
208         /// <param name="deleteCommand">A valid SQL statement to delete records from the data source</param>
209         /// <param name="updateCommand">A valid SQL statement used to update records in the data source</param>
210         /// <param name="dataSet">The DataSet used to update the data source</param>
211         /// <param name="tableName">The DataTable used to update the data source.</param>
212         public static void UpdateDataset(SQLiteCommand insertCommand, SQLiteCommand deleteCommand, SQLiteCommand updateCommand, DataSet dataSet, string tableName)
213         {
214             if (insertCommand == null) throw new ArgumentNullException("insertCommand");
215             if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
216             if (updateCommand == null) throw new ArgumentNullException("updateCommand");
217             if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
218 
219             // Create a SQLiteDataAdapter, and dispose of it after we are done
220             using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter())
221             {
222                 // Set the data adapter commands
223                 dataAdapter.UpdateCommand = updateCommand;
224                 dataAdapter.InsertCommand = insertCommand;
225                 dataAdapter.DeleteCommand = deleteCommand;
226 
227                 // Update the dataset changes in the data source
228                 dataAdapter.Update(dataSet, tableName);
229 
230                 // Commit all the changes made to the DataSet
231                 dataSet.AcceptChanges();
232             }
233         }
234         #endregion
235 
236 
237 
238 
239         /// <summary>
240         /// ShortCut method to return IDataReader
241         /// NOTE: You should explicitly close the Command.connection you passed in as
242         /// well as call Dispose on the Command  after reader is closed.
243         /// We do this because IDataReader has no underlying Connection Property.
244         /// </summary>
245         /// <param name="cmd">SQLiteCommand Object</param>
246         /// <param name="commandText">SQL Statement with optional embedded "@param" style parameters</param>
247         /// <param name="paramList">object[] array of parameter values</param>
248         /// <returns>IDataReader</returns>
249         public static IDataReader ExecuteReader(SQLiteCommand cmd, string commandText, object[] paramList)
250         {
251             if (cmd.Connection == null)
252                 throw new ArgumentException("Command must have live connection attached.", "cmd");
253             cmd.CommandText = commandText;
254             AttachParameters(cmd, commandText, paramList);
255             if (cmd.Connection.State == ConnectionState.Closed)
256                 cmd.Connection.Open();
257             IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
258             return rdr;
259         }
260 
261         /// <summary>
262         /// Shortcut to ExecuteNonQuery with SqlStatement and object[] param values
263         /// </summary>
264         /// <param name="connectionString">SQLite Connection String</param>
265         /// <param name="commandText">Sql Statement with embedded "@param" style parameters</param>
266         /// <param name="paramList">object[] array of parameter values</param>
267         /// <returns></returns>
268         public static int ExecuteNonQuery(string connectionString, string commandText, params object[] paramList)
269         {
270             SQLiteConnection cn = new SQLiteConnection(connectionString);
271             SQLiteCommand cmd = cn.CreateCommand();
272             cmd.CommandText = commandText;
273             AttachParameters(cmd, commandText, paramList);
274             if (cn.State == ConnectionState.Closed)
275                 cn.Open();
276             int result = cmd.ExecuteNonQuery();
277             cmd.Dispose();
278             cn.Close();
279 
280             return result;
281         }
282 
283 
284 
285         public static int ExecuteNonQuery(SQLiteConnection cn, string commandText, params object[] paramList)
286         {
287 
288             SQLiteCommand cmd = cn.CreateCommand();
289             cmd.CommandText = commandText;
290             AttachParameters(cmd, commandText, paramList);
291             if (cn.State == ConnectionState.Closed)
292                 cn.Open();
293             int result = cmd.ExecuteNonQuery();
294             cmd.Dispose();
295             cn.Close();
296 
297             return result;
298         }
299 
300         /// <summary>
301         /// Executes  non-query sql Statment with Transaction
302         /// </summary>
303         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,   /// and Command, all of which must be created prior to making this method call. </param>
304         /// <param name="commandText">Command text.</param>
305         /// <param name="paramList">Param list.</param>
306         /// <returns>Integer</returns>
307         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
308         public static int ExecuteNonQuery(SQLiteTransaction transaction, string commandText, params object[] paramList)
309         {
310             if (transaction == null) throw new ArgumentNullException("transaction");
311             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,                                                        please provide an open transaction.", "transaction");
312             IDbCommand cmd = transaction.Connection.CreateCommand();
313             cmd.CommandText = commandText;
314             AttachParameters((SQLiteCommand)cmd, cmd.CommandText, paramList);
315             if (transaction.Connection.State == ConnectionState.Closed)
316                 transaction.Connection.Open();
317             int result = cmd.ExecuteNonQuery();
318             cmd.Dispose();
319             return result;
320         }
321 
322 
323         /// <summary>
324         /// Executes the non query.
325         /// </summary>
326         /// <param name="cmd">CMD.</param>
327         /// <returns></returns>
328         public static int ExecuteNonQuery(IDbCommand cmd)
329         {
330             if (cmd.Connection.State == ConnectionState.Closed)
331                 cmd.Connection.Open();
332             int result = cmd.ExecuteNonQuery();
333             cmd.Connection.Close();
334             cmd.Dispose();
335             return result;
336         }
337 
338         /// <summary>
339         /// Shortcut to ExecuteScalar with Sql Statement embedded params and object[] param values
340         /// </summary>
341         /// <param name="connectionString">SQLite Connection String</param>
342         /// <param name="commandText">SQL statment with embedded "@param" style parameters</param>
343         /// <param name="paramList">object[] array of param values</param>
344         /// <returns></returns>
345         public static object ExecuteScalar(string connectionString, string commandText, params object[] paramList)
346         {
347             SQLiteConnection cn = new SQLiteConnection(connectionString);
348             SQLiteCommand cmd = cn.CreateCommand();
349             cmd.CommandText = commandText;
350             AttachParameters(cmd, commandText, paramList);
351             if (cn.State == ConnectionState.Closed)
352                 cn.Open();
353             object result = cmd.ExecuteScalar();
354             cmd.Dispose();
355             cn.Close();
356 
357             return result;
358         }
359 
360         /// <summary>
361         /// Execute XmlReader with complete Command
362         /// </summary>
363         /// <param name="command">SQLite Command</param>
364         /// <returns>XmlReader</returns>
365         public static XmlReader ExecuteXmlReader(IDbCommand command)
366         { // open the connection if necessary, but make sure we 
367             // know to close it when we�re done.
368             if (command.Connection.State != ConnectionState.Open)
369             {
370                 command.Connection.Open();
371             }
372 
373             // get a data adapter  
374             SQLiteDataAdapter da = new SQLiteDataAdapter((SQLiteCommand)command);
375             DataSet ds = new DataSet();
376             // fill the data set, and return the schema information
377             da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
378             da.Fill(ds);
379             // convert our dataset to XML
380             StringReader stream = new StringReader(ds.GetXml());
381             command.Connection.Close();
382             // convert our stream of text to an XmlReader
383             return new XmlTextReader(stream);
384         }
385 
386 
387 
388         /// <summary>
389         /// Parses parameter names from SQL Statement, assigns values from object array ,   /// and returns fully populated ParameterCollection.
390         /// </summary>
391         /// <param name="commandText">Sql Statement with "@param" style embedded parameters</param>
392         /// <param name="paramList">object[] array of parameter values</param>
393         /// <returns>SQLiteParameterCollection</returns>
394         /// <remarks>Status experimental. Regex appears to be handling most issues. Note that parameter object array must be in same ///order as parameter names appear in SQL statement.</remarks>
395         private static SQLiteParameterCollection AttachParameters(SQLiteCommand cmd, string commandText, params object[] paramList)
396         {
397             if (paramList == null || paramList.Length == 0) return null;
398 
399             SQLiteParameterCollection coll = cmd.Parameters;
400             string parmString = commandText.Substring(commandText.IndexOf("@"));
401             // pre-process the string so always at least 1 space after a comma.
402             parmString = parmString.Replace(",", " ,");
403             // get the named parameters into a match collection
404             string pattern = @"(@)\S*(.*?)\b";
405             Regex ex = new Regex(pattern, RegexOptions.IgnoreCase);
406             MatchCollection mc = ex.Matches(parmString);
407             string[] paramNames = new string[mc.Count];
408             int i = 0;
409             foreach (Match m in mc)
410             {
411                 paramNames[i] = m.Value;
412                 i++;
413             }
414 
415             // now let's type the parameters
416             int j = 0;
417             Type t = null;
418             foreach (object o in paramList)
419             {
420                 t = o.GetType();
421 
422                 SQLiteParameter parm = new SQLiteParameter();
423                 switch (t.ToString())
424                 {
425 
426                     case ("DBNull"):
427                     case ("Char"):
428                     case ("SByte"):
429                     case ("UInt16"):
430                     case ("UInt32"):
431                     case ("UInt64"):
432                         throw new SystemException("Invalid data type");
433 
434 
435                     case ("System.String"):
436                         parm.DbType = DbType.String;
437                         parm.ParameterName = paramNames[j];
438                         parm.Value = (string)paramList[j];
439                         coll.Add(parm);
440                         break;
441 
442                     case ("System.Byte[]"):
443                         parm.DbType = DbType.Binary;
444                         parm.ParameterName = paramNames[j];
445                         parm.Value = (byte[])paramList[j];
446                         coll.Add(parm);
447                         break;
448 
449                     case ("System.Int32"):
450                         parm.DbType = DbType.Int32;
451                         parm.ParameterName = paramNames[j];
452                         parm.Value = (int)paramList[j];
453                         coll.Add(parm);
454                         break;
455 
456                     case ("System.Boolean"):
457                         parm.DbType = DbType.Boolean;
458                         parm.ParameterName = paramNames[j];
459                         parm.Value = (bool)paramList[j];
460                         coll.Add(parm);
461                         break;
462 
463                     case ("System.DateTime"):
464                         parm.DbType = DbType.DateTime;
465                         parm.ParameterName = paramNames[j];
466                         parm.Value = Convert.ToDateTime(paramList[j]);
467                         coll.Add(parm);
468                         break;
469 
470                     case ("System.Double"):
471                         parm.DbType = DbType.Double;
472                         parm.ParameterName = paramNames[j];
473                         parm.Value = Convert.ToDouble(paramList[j]);
474                         coll.Add(parm);
475                         break;
476 
477                     case ("System.Decimal"):
478                         parm.DbType = DbType.Decimal;
479                         parm.ParameterName = paramNames[j];
480                         parm.Value = Convert.ToDecimal(paramList[j]);
481                         break;
482 
483                     case ("System.Guid"):
484                         parm.DbType = DbType.Guid;
485                         parm.ParameterName = paramNames[j];
486                         parm.Value = (System.Guid)(paramList[j]);
487                         break;
488 
489                     case ("System.Object"):
490 
491                         parm.DbType = DbType.Object;
492                         parm.ParameterName = paramNames[j];
493                         parm.Value = paramList[j];
494                         coll.Add(parm);
495                         break;
496 
497                     default:
498                         throw new SystemException("Value is of unknown data type");
499 
500                 } // end switch
501 
502                 j++;
503             }
504             return coll;
505         }
506 
507         /// <summary>
508         /// Executes non query typed params from a DataRow
509         /// </summary>
510         /// <param name="command">Command.</param>
511         /// <param name="dataRow">Data row.</param>
512         /// <returns>Integer result code</returns>
513         public static int ExecuteNonQueryTypedParams(IDbCommand command, DataRow dataRow)
514         {
515             int retVal = 0;
516 
517             // If the row has values, the store procedure parameters must be initialized
518             if (dataRow != null && dataRow.ItemArray.Length > 0)
519             {
520                 // Set the parameters values
521                 AssignParameterValues(command.Parameters, dataRow);
522 
523                 retVal = ExecuteNonQuery(command);
524             }
525             else
526             {
527                 retVal = ExecuteNonQuery(command);
528             }
529 
530             return retVal;
531         }
532 
533         /// <summary>
534         /// This method assigns dataRow column values to an IDataParameterCollection
535         /// </summary>
536         /// <param name="commandParameters">The IDataParameterCollection to be assigned values</param>
537         /// <param name="dataRow">The dataRow used to hold the command's parameter values</param>
538         /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
539         protected internal static void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow)
540         {
541             if (commandParameters == null || dataRow == null)
542             {
543                 // Do nothing if we get no data
544                 return;
545             }
546 
547             DataColumnCollection columns = dataRow.Table.Columns;
548 
549             int i = 0;
550             // Set the parameters values
551             foreach (IDataParameter commandParameter in commandParameters)
552             {
553                 // Check the parameter name
554                 if (commandParameter.ParameterName == null ||
555                  commandParameter.ParameterName.Length <= 1)
556                     throw new InvalidOperationException(string.Format(
557                            "Please provide a valid parameter name on the parameter #{0},                            the ParameterName property has the following value: '{1}'.",
558                      i, commandParameter.ParameterName));
559 
560                 if (columns.Contains(commandParameter.ParameterName))
561                     commandParameter.Value = dataRow[commandParameter.ParameterName];
562                 else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
563                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
564 
565                 i++;
566             }
567         }
568 
569         /// <summary>
570         /// This method assigns dataRow column values to an array of IDataParameters
571         /// </summary>
572         /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
573         /// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
574         /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
575         protected void AssignParameterValues(IDataParameter[] commandParameters, DataRow dataRow)
576         {
577             if ((commandParameters == null) || (dataRow == null))
578             {
579                 // Do nothing if we get no data
580                 return;
581             }
582 
583             DataColumnCollection columns = dataRow.Table.Columns;
584 
585             int i = 0;
586             // Set the parameters values
587             foreach (IDataParameter commandParameter in commandParameters)
588             {
589                 // Check the parameter name
590                 if (commandParameter.ParameterName == null ||
591                  commandParameter.ParameterName.Length <= 1)
592                     throw new InvalidOperationException(string.Format(
593                      "Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
594                      i, commandParameter.ParameterName));
595 
596                 if (columns.Contains(commandParameter.ParameterName))
597                     commandParameter.Value = dataRow[commandParameter.ParameterName];
598                 else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
599                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
600 
601                 i++;
602             }
603         }
604 
605         /// <summary>
606         /// This method assigns an array of values to an array of IDataParameters
607         /// </summary>
608         /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
609         /// <param name="parameterValues">Array of objects holding the values to be assigned</param>
610         /// <exception cref="System.ArgumentException">Thrown if an incorrect number of parameters are passed.</exception>
611         protected void AssignParameterValues(IDataParameter[] commandParameters, params object[] parameterValues)
612         {
613             if ((commandParameters == null) || (parameterValues == null))
614             {
615                 // Do nothing if we get no data
616                 return;
617             }
618 
619             // We must have the same number of values as we pave parameters to put them in
620             if (commandParameters.Length != parameterValues.Length)
621             {
622                 throw new ArgumentException("Parameter count does not match Parameter Value count.");
623             }
624 
625             // Iterate through the IDataParameters, assigning the values from the corresponding position in the 
626             // value array
627             for (int i = 0, j = commandParameters.Length, k = 0; i < j; i++)
628             {
629                 if (commandParameters[i].Direction != ParameterDirection.ReturnValue)
630                 {
631                     // If the current array value derives from IDataParameter, then assign its Value property
632                     if (parameterValues[k] is IDataParameter)
633                     {
634                         IDataParameter paramInstance;
635                         paramInstance = (IDataParameter)parameterValues[k];
636                         if (paramInstance.Direction == ParameterDirection.ReturnValue)
637                         {
638                             paramInstance = (IDataParameter)parameterValues[++k];
639                         }
640                         if (paramInstance.Value == null)
641                         {
642                             commandParameters[i].Value = DBNull.Value;
643                         }
644                         else
645                         {
646                             commandParameters[i].Value = paramInstance.Value;
647                         }
648                     }
649                     else if (parameterValues[k] == null)
650                     {
651                         commandParameters[i].Value = DBNull.Value;
652                     }
653                     else
654                     {
655                         commandParameters[i].Value = parameterValues[k];
656                     }
657                     k++;
658                 }
659             }
660         }
661     }
662 }
posted on 2018-04-10 15:53 浩凡儿阅读(613) 评论(0) 编辑收藏举报