C#操作SQLite数据库

1、SQLite介绍

2、C#操作SQLite Database

2.1 C#下SQLite操作驱动dll下载

2.2 C#使用SQLite步骤

(1)新建一个project

(2)添加SQLite操作驱动dll引用

(3)使用API操作SQLite DataBase

2.3 操作SQLite Database的C#帮助类SQLite Helper

1、SQLite介绍

SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.

SQLite是一个开源、免费的小型RDBMS(关系型数据库),能独立运行、无服务器、零配置、支持事物,用C实现,内存占用较小,支持绝大数的SQL92标准。

SQLite数据库官方主页:http://www.sqlite.org/index.html

2、C#操作SQLite Database

2.1 C#下SQLite操作驱动dll下载

C#下SQLite操作驱动dll下载:System.Data.SQLite

2.2 C#使用SQLite步骤

(1)新建一个project

(2)添加SQLite操作驱动dll引用

(3)使用API操作SQLite DataBase


    
  1. using System;
  2. using System.Data.SQLite;
  3. namespace SQLiteSamples
  4. {
  5. class Program
  6. {
  7. //数据库连接
  8. SQLiteConnection m_dbConnection;
  9. static void Main(string[] args)
  10. {
  11. Program p = new Program();
  12. }
  13. public Program()
  14. {
  15. createNewDatabase();
  16. connectToDatabase();
  17. createTable();
  18. fillTable();
  19. printHighscores();
  20. }
  21. //创建一个空的数据库
  22. void createNewDatabase()
  23. {
  24. SQLiteConnection.CreateFile( "MyDatabase.sqlite");
  25. }
  26. //创建一个连接到指定数据库
  27. void connectToDatabase()
  28. {
  29. m_dbConnection = new SQLiteConnection( "Data Source=MyDatabase.sqlite;Version=3;");
  30. m_dbConnection.Open();
  31. }
  32. //在指定数据库中创建一个table
  33. void createTable()
  34. {
  35. string sql = "create table highscores (name varchar(20), score int)";
  36. SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
  37. command.ExecuteNonQuery();
  38. }
  39. //插入一些数据
  40. void fillTable()
  41. {
  42. string sql = "insert into highscores (name, score) values ('Me', 3000)";
  43. SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
  44. command.ExecuteNonQuery();
  45. sql = "insert into highscores (name, score) values ('Myself', 6000)";
  46. command = new SQLiteCommand(sql, m_dbConnection);
  47. command.ExecuteNonQuery();
  48. sql = "insert into highscores (name, score) values ('And I', 9001)";
  49. command = new SQLiteCommand(sql, m_dbConnection);
  50. command.ExecuteNonQuery();
  51. }
  52. //使用sql查询语句,并显示结果
  53. void printHighscores()
  54. {
  55. string sql = "select * from highscores order by score desc";
  56. SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
  57. SQLiteDataReader reader = command.ExecuteReader();
  58. while (reader.Read())
  59. Console.WriteLine( "Name: " + reader[ "name"] + "\tScore: " + reader[ "score"]);
  60. Console.ReadLine();
  61. }
  62. }
  63. }

关于SQLite的connection string说明:http://www.connectionstrings.com/sqlite/

SQLite GUI客户端列表:http://www.sqlite.org/cvstrac/wiki?p=ManagementTools

SQLite Administrator下载地址:http://download.orbmu2k.de/files/sqliteadmin.zip

2.3 操作SQLite Database的C#帮助类SQLite Helper

将一些常用的功能封装一下,封装成SQLite Helper类


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

Codeproject上的一个封装:http://www.codeproject.com/Articles/746191/SQLite-Helper-Csharp

作者:阿凡卢

出处:http://www.cnblogs.com/luxiaoxun/

本文版权归作者所有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐