C# implémente des méthodes d'accès à la base de données SQLite basées sur la classe SQLiteHelper similaire à la classe SqlHelper-Tutoriel C#.Net-php.cn

L'exemple de cet article décrit comment C# implémente l'accès à la base de données SQLite basé sur la classe SqlHelper de type SQLiteHelper. Partagez-le avec tout le monde pour votre référence. Les détails sont les suivants :
Cette classe n'est pas implémentée par moi. L'adresse originale en anglais est http://www.eggheadcafe.com/articles/20050315.asp. l'article original est modifié ici. La méthode est Changez le nom en AttachParameters, changez son modificateur en private, passez la commande directement à cette méthode et liez les paramètres directement à la commande. Le code modifié est le suivant
using System;
using System.Data;
using System.Text.RegularExpressions;
using System.Xml;
using System.IO;
using System.Collections;
using System.Data.SQLite;
namespace DBUtility.SQLite
{
 /// <summary>
 /// SQLiteHelper is a utility class similar to "SQLHelper" in MS
 /// Data Access Application Block and follows similar pattern.
 /// </summary>
 public class SQLiteHelper
 {
  /// <summary>
  /// Creates a new <see cref="SQLiteHelper"/> instance. The ctor is marked private since all members are static.
  /// </summary>
  private SQLiteHelper()
  {
  }
  /// <summary>
  /// Creates the command.
  /// </summary>
  /// <param name="connection">Connection.</param>
  /// <param name="commandText">Command text.</param>
  /// <param name="commandParameters">Command parameters.</param>
  /// <returns>SQLite Command</returns>
  public static SQLiteCommand CreateCommand(SQLiteConnection connection, string commandText, params SQLiteParameter[] commandParameters)
  {
   SQLiteCommand cmd = new SQLiteCommand(commandText, connection);
   if (commandParameters.Length > 0)
   {
    foreach (SQLiteParameter parm in commandParameters)
     cmd.Parameters.Add(parm);
   }
   return cmd;
  }
  /// <summary>
  /// Creates the command.
  /// </summary>
  /// <param name="connectionString">Connection string.</param>
  /// <param name="commandText">Command text.</param>
  /// <param name="commandParameters">Command parameters.</param>
  /// <returns>SQLite Command</returns>
  public static SQLiteCommand CreateCommand(string connectionString, string commandText, params SQLiteParameter[] commandParameters)
  {
   SQLiteConnection cn = new SQLiteConnection(connectionString);
   SQLiteCommand cmd = new SQLiteCommand(commandText, cn);
   if (commandParameters.Length > 0)
   {
    foreach (SQLiteParameter parm in commandParameters)
     cmd.Parameters.Add(parm);
   }
   return cmd;
  }
  /// <summary>
  /// Creates the parameter.
  /// </summary>
  /// <param name="parameterName">Name of the parameter.</param>
  /// <param name="parameterType">Parameter type.</param>
  /// <param name="parameterValue">Parameter value.</param>
  /// <returns>SQLiteParameter</returns>
  public static SQLiteParameter CreateParameter(string parameterName, System.Data.DbType parameterType, object parameterValue)
  {
   SQLiteParameter parameter = new SQLiteParameter();
   parameter.DbType = parameterType;
   parameter.ParameterName = parameterName;
   parameter.Value = parameterValue;
   return parameter;
  }
  /// <summary>
  /// Shortcut method to execute dataset from SQL Statement and object[] arrray of parameter values
  /// </summary>
  /// <param name="connectionString">SQLite Connection string</param>
  /// <param name="commandText">SQL Statement with embedded "@param" style parameter names</param>
  /// <param name="paramList">object[] array of parameter values</param>
  /// <returns></returns>
  public static DataSet ExecuteDataSet(string connectionString, string commandText, object[] paramList)
  {
   SQLiteConnection cn = new SQLiteConnection(connectionString);
   SQLiteCommand cmd = cn.CreateCommand();
 
   cmd.CommandText = commandText;
   if (paramList != null)
   {
    AttachParameters(cmd,commandText, paramList);
   }
   DataSet ds = new DataSet();
   if (cn.State == ConnectionState.Closed)
    cn.Open();
   SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
   da.Fill(ds);
   da.Dispose();
   cmd.Dispose();
   cn.Close();
   return ds;
  }
  /// <summary>
  /// Shortcut method to execute dataset from SQL Statement and object[] arrray of parameter values
  /// </summary>
  /// <param name="cn">Connection.</param>
  /// <param name="commandText">Command text.</param>
  /// <param name="paramList">Param list.</param>
  /// <returns></returns>
  public static DataSet ExecuteDataSet(SQLiteConnection cn, string commandText, object[] paramList)
  {
   SQLiteCommand cmd = cn.CreateCommand();
 
   cmd.CommandText = commandText;
   if (paramList != null)
   {
    AttachParameters(cmd,commandText, paramList);
   }
   DataSet ds = new DataSet();
   if (cn.State == ConnectionState.Closed)
    cn.Open();
   SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
   da.Fill(ds);
   da.Dispose();
   cmd.Dispose();
   cn.Close();
   return ds;
  }
  /// <summary>
  /// Executes the dataset from a populated Command object.
  /// </summary>
  /// <param name="cmd">Fully populated SQLiteCommand</param>
  /// <returns>DataSet</returns>
  public static DataSet ExecuteDataset(SQLiteCommand cmd)
  {
   if (cmd.Connection.State == ConnectionState.Closed)
    cmd.Connection.Open();
   DataSet ds = new DataSet();
   SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
   da.Fill(ds);
   da.Dispose();
   cmd.Connection.Close();
   cmd.Dispose();
   return ds;
  }
  /// <summary>
  /// Executes the dataset in a SQLite Transaction
  /// </summary>
  /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction, /// and Command, all of which must be created prior to making this method call. </param>
  /// <param name="commandText">Command text.</param>
  /// <param name="commandParameters">Sqlite Command parameters.</param>
  /// <returns>DataSet</returns>
  /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
  public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, params SQLiteParameter[] commandParameters)
  {
   if (transaction == null) throw new ArgumentNullException("transaction");
   if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed, please provide an open transaction.", "transaction");
   IDbCommand cmd = transaction.Connection.CreateCommand();
   cmd.CommandText = commandText;
   foreach (SQLiteParameter parm in commandParameters)
   {
    cmd.Parameters.Add(parm);
   }
   if (transaction.Connection.State == ConnectionState.Closed)
    transaction.Connection.Open();
   DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
   return ds;
  }
  /// <summary>
  /// Executes the dataset with Transaction and object array of parameter values.
  /// </summary>
  /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction, /// and Command, all of which must be created prior to making this method call. </param>
  /// <param name="commandText">Command text.</param>
  /// <param name="commandParameters">object[] array of parameter values.</param>
  /// <returns>DataSet</returns>
  /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
  public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, object[] commandParameters)
  {
   if (transaction == null) throw new ArgumentNullException("transaction");
   if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,               please provide an open transaction.", "transaction");
   IDbCommand cmd = transaction.Connection.CreateCommand();
   cmd.CommandText = commandText;
   AttachParameters((SQLiteCommand)cmd,cmd.CommandText, commandParameters);
   if (transaction.Connection.State == ConnectionState.Closed)
    transaction.Connection.Open();
   DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
   return ds;
  }
  #region UpdateDataset
  /// <summary>
  /// Executes the respective command for each inserted, updated, or deleted row in the DataSet.
  /// </summary>
  /// <remarks>
  /// e.g.: 
  /// UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
  /// </remarks>
  /// <param name="insertCommand">A valid SQL statement to insert new records into the data source</param>
  /// <param name="deleteCommand">A valid SQL statement to delete records from the data source</param>
  /// <param name="updateCommand">A valid SQL statement used to update records in the data source</param>
  /// <param name="dataSet">The DataSet used to update the data source</param>
  /// <param name="tableName">The DataTable used to update the data source.</param>
  public static void UpdateDataset(SQLiteCommand insertCommand, SQLiteCommand deleteCommand, SQLiteCommand updateCommand, DataSet dataSet, string tableName)
  {
   if (insertCommand == null) throw new ArgumentNullException("insertCommand");
   if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
   if (updateCommand == null) throw new ArgumentNullException("updateCommand");
   if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
   // Create a SQLiteDataAdapter, and dispose of it after we are done
   using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter())
   {
    // Set the data adapter commands
    dataAdapter.UpdateCommand = updateCommand;
    dataAdapter.InsertCommand = insertCommand;
    dataAdapter.DeleteCommand = deleteCommand;
    // Update the dataset changes in the data source
    dataAdapter.Update(dataSet, tableName);
    // Commit all the changes made to the DataSet
    dataSet.AcceptChanges();
   }
  }
  #endregion
 
 
  /// <summary>
  /// ShortCut method to return IDataReader
  /// NOTE: You should explicitly close the Command.connection you passed in as
  /// well as call Dispose on the Command after reader is closed.
  /// We do this because IDataReader has no underlying Connection Property.
  /// </summary>
  /// <param name="cmd">SQLiteCommand Object</param>
  /// <param name="commandText">SQL Statement with optional embedded "@param" style parameters</param>
  /// <param name="paramList">object[] array of parameter values</param>
  /// <returns>IDataReader</returns>
  public static IDataReader ExecuteReader(SQLiteCommand cmd, string commandText, object[] paramList)
  {
   if (cmd.Connection == null)
    throw new ArgumentException("Command must have live connection attached.", "cmd");
   cmd.CommandText = commandText;
   AttachParameters(cmd,commandText, paramList);
   if (cmd.Connection.State == ConnectionState.Closed)
    cmd.Connection.Open();
   IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
   return rdr;
  }
  /// <summary>
  /// Shortcut to ExecuteNonQuery with SqlStatement and object[] param values
  /// </summary>
  /// <param name="connectionString">SQLite Connection String</param>
  /// <param name="commandText">Sql Statement with embedded "@param" style parameters</param>
  /// <param name="paramList">object[] array of parameter values</param>
  /// <returns></returns>
  public static int ExecuteNonQuery(string connectionString, string commandText, params object[] paramList)
  {
   SQLiteConnection cn = new SQLiteConnection(connectionString);
   SQLiteCommand cmd = cn.CreateCommand();
   cmd.CommandText = commandText;
   AttachParameters(cmd,commandText, paramList);
   if (cn.State == ConnectionState.Closed)
    cn.Open();
   int result = cmd.ExecuteNonQuery();
   cmd.Dispose();
   cn.Close();
   return result;
  }
 
  public static int ExecuteNonQuery(SQLiteConnection cn, string commandText, params object[] paramList)
  {
   SQLiteCommand cmd = cn.CreateCommand();
   cmd.CommandText = commandText;
   AttachParameters(cmd,commandText, paramList);
   if (cn.State == ConnectionState.Closed)
    cn.Open();
   int result = cmd.ExecuteNonQuery();
   cmd.Dispose();
   cn.Close();
   return result;
  }
  /// <summary>
  /// Executes non-query sql Statment with Transaction
  /// </summary>
  /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction, /// and Command, all of which must be created prior to making this method call. </param>
  /// <param name="commandText">Command text.</param>
  /// <param name="paramList">Param list.</param>
  /// <returns>Integer</returns>
  /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
  public static int ExecuteNonQuery(SQLiteTransaction transaction, string commandText, params object[] paramList)
  {
   if (transaction == null) throw new ArgumentNullException("transaction");
   if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,              please provide an open transaction.", "transaction");
   IDbCommand cmd = transaction.Connection.CreateCommand();
   cmd.CommandText = commandText;
   AttachParameters((SQLiteCommand)cmd,cmd.CommandText, paramList);
   if (transaction.Connection.State == ConnectionState.Closed)
    transaction.Connection.Open();
   int result = cmd.ExecuteNonQuery();
   cmd.Dispose();
   return result;
  }
 
  /// <summary>
  /// Executes the non query.
  /// </summary>
  /// <param name="cmd">CMD.</param>
  /// <returns></returns>
  public static int ExecuteNonQuery(IDbCommand cmd)
  {
   if (cmd.Connection.State == ConnectionState.Closed)
    cmd.Connection.Open();
   int result = cmd.ExecuteNonQuery();
   cmd.Connection.Close();
   cmd.Dispose();
   return result;
  }
  /// <summary>
  /// Shortcut to ExecuteScalar with Sql Statement embedded params and object[] param values
  /// </summary>
  /// <param name="connectionString">SQLite Connection String</param>
  /// <param name="commandText">SQL statment with embedded "@param" style parameters</param>
  /// <param name="paramList">object[] array of param values</param>
  /// <returns></returns>
  public static object ExecuteScalar(string connectionString, string commandText, params object[] paramList)
  {
   SQLiteConnection cn = new SQLiteConnection(connectionString);
   SQLiteCommand cmd = cn.CreateCommand();
   cmd.CommandText = commandText;
   AttachParameters(cmd,commandText, paramList);
   if (cn.State == ConnectionState.Closed)
    cn.Open();
   object result = cmd.ExecuteScalar();
   cmd.Dispose();
   cn.Close();
   return result;
  }
  /// <summary>
  /// Execute XmlReader with complete Command
  /// </summary>
  /// <param name="command">SQLite Command</param>
  /// <returns>XmlReader</returns>
  public static XmlReader ExecuteXmlReader(IDbCommand command)
  { // open the connection if necessary, but make sure we 
   // know to close it when we�re done.
   if (command.Connection.State != ConnectionState.Open)
   {
    command.Connection.Open();
   }
   // get a data adapter 
   SQLiteDataAdapter da = new SQLiteDataAdapter((SQLiteCommand)command);
   DataSet ds = new DataSet();
   // fill the data set, and return the schema information
   da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
   da.Fill(ds);
   // convert our dataset to XML
   StringReader stream = new StringReader(ds.GetXml());
   command.Connection.Close();
   // convert our stream of text to an XmlReader
   return new XmlTextReader(stream);
  }
 
  /// <summary>
  /// Parses parameter names from SQL Statement, assigns values from object array , /// and returns fully populated ParameterCollection.
  /// </summary>
  /// <param name="commandText">Sql Statement with "@param" style embedded parameters</param>
  /// <param name="paramList">object[] array of parameter values</param>
  /// <returns>SQLiteParameterCollection</returns>
  /// <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>
  private static SQLiteParameterCollection AttachParameters(SQLiteCommand cmd, string commandText, params object[] paramList)
  {
   if (paramList == null || paramList.Length == 0) return null;
   SQLiteParameterCollection coll = cmd.Parameters;
   string parmString = commandText.Substring(commandText.IndexOf("@"));
   // pre-process the string so always at least 1 space after a comma.
   parmString = parmString.Replace(",", " ,");
   // get the named parameters into a match collection
   string pattern = @"(@)\S*(.*?)\b";
   Regex ex = new Regex(pattern, RegexOptions.IgnoreCase);
   MatchCollection mc = ex.Matches(parmString);
   string[] paramNames = new string[mc.Count];
   int i = 0;
   foreach (Match m in mc)
   {
    paramNames[i] = m.Value;
    i++;
   }
   // now let&#39;s type the parameters
   int j = 0;
   Type t = null;
   foreach (object o in paramList)
   {
    t = o.GetType();
    SQLiteParameter parm = new SQLiteParameter();
    switch (t.ToString())
    {
     case ("DBNull"):
     case ("Char"):
     case ("SByte"):
     case ("UInt16"):
     case ("UInt32"):
     case ("UInt64"):
      throw new SystemException("Invalid data type");
 
     case ("System.String"):
      parm.DbType = DbType.String;
      parm.ParameterName = paramNames[j];
      parm.Value = (string)paramList[j];
      coll.Add(parm);
      break;
     case ("System.Byte[]"):
      parm.DbType = DbType.Binary;
      parm.ParameterName = paramNames[j];
      parm.Value = (byte[])paramList[j];
      coll.Add(parm);
      break;
     case ("System.Int32"):
      parm.DbType = DbType.Int32;
      parm.ParameterName = paramNames[j];
      parm.Value = (int)paramList[j];
      coll.Add(parm);
      break;
     case ("System.Boolean"):
      parm.DbType = DbType.Boolean;
      parm.ParameterName = paramNames[j];
      parm.Value = (bool)paramList[j];
      coll.Add(parm);
      break;
     case ("System.DateTime"):
      parm.DbType = DbType.DateTime;
      parm.ParameterName = paramNames[j];
      parm.Value = Convert.ToDateTime(paramList[j]);
      coll.Add(parm);
      break;
     case ("System.Double"):
      parm.DbType = DbType.Double;
      parm.ParameterName = paramNames[j];
      parm.Value = Convert.ToDouble(paramList[j]);
      coll.Add(parm);
      break;
     case ("System.Decimal"):
      parm.DbType = DbType.Decimal;
      parm.ParameterName = paramNames[j];
      parm.Value = Convert.ToDecimal(paramList[j]);
      break;
     case ("System.Guid"):
      parm.DbType = DbType.Guid;
      parm.ParameterName = paramNames[j];
      parm.Value = (System.Guid)(paramList[j]);
      break;
     case ("System.Object"):
      parm.DbType = DbType.Object;
      parm.ParameterName = paramNames[j];
      parm.Value = paramList[j];
      coll.Add(parm);
      break;
     default:
      throw new SystemException("Value is of unknown data type");
    } // end switch
    j++;
   }
   return coll;
  }
  /// <summary>
  /// Executes non query typed params from a DataRow
  /// </summary>
  /// <param name="command">Command.</param>
  /// <param name="dataRow">Data row.</param>
  /// <returns>Integer result code</returns>
  public static int ExecuteNonQueryTypedParams(IDbCommand command, DataRow dataRow)
  {
   int retVal = 0;
   // If the row has values, the store procedure parameters must be initialized
   if (dataRow != null && dataRow.ItemArray.Length > 0)
   {
    // Set the parameters values
    AssignParameterValues(command.Parameters, dataRow);
    retVal = ExecuteNonQuery(command);
   }
   else
   {
    retVal = ExecuteNonQuery(command);
   }
   return retVal;
  }
  /// <summary>
  /// This method assigns dataRow column values to an IDataParameterCollection
  /// </summary>
  /// <param name="commandParameters">The IDataParameterCollection to be assigned values</param>
  /// <param name="dataRow">The dataRow used to hold the command&#39;s parameter values</param>
  /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
  protected internal static void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow)
  {
   if (commandParameters == null || dataRow == null)
   {
    // Do nothing if we get no data
    return;
   }
   DataColumnCollection columns = dataRow.Table.Columns;
   int i = 0;
   // Set the parameters values
   foreach (IDataParameter commandParameter in commandParameters)
   {
    // Check the parameter name
    if (commandParameter.ParameterName == null ||
     commandParameter.ParameterName.Length <= 1)
     throw new InvalidOperationException(string.Format(
       "Please provide a valid parameter name on the parameter #{0},       the ParameterName property has the following value: &#39;{1}&#39;.",
      i, commandParameter.ParameterName));
    if (columns.Contains(commandParameter.ParameterName))
     commandParameter.Value = dataRow[commandParameter.ParameterName];
    else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
    i++;
   }
  }
  /// <summary>
  /// This method assigns dataRow column values to an array of IDataParameters
  /// </summary>
  /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
  /// <param name="dataRow">The dataRow used to hold the stored procedure&#39;s parameter values</param>
  /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
  protected void AssignParameterValues(IDataParameter[] commandParameters, DataRow dataRow)
  {
   if ((commandParameters == null) || (dataRow == null))
   {
    // Do nothing if we get no data
    return;
   }
   DataColumnCollection columns = dataRow.Table.Columns;
   int i = 0;
   // Set the parameters values
   foreach (IDataParameter commandParameter in commandParameters)
   {
    // Check the parameter name
    if (commandParameter.ParameterName == null ||
     commandParameter.ParameterName.Length <= 1)
     throw new InvalidOperationException(string.Format(
      "Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: &#39;{1}&#39;.",
      i, commandParameter.ParameterName));
    if (columns.Contains(commandParameter.ParameterName))
     commandParameter.Value = dataRow[commandParameter.ParameterName];
    else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
    i++;
   }
  }
  /// <summary>
  /// This method assigns an array of values to an array of IDataParameters
  /// </summary>
  /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
  /// <param name="parameterValues">Array of objects holding the values to be assigned</param>
  /// <exception cref="System.ArgumentException">Thrown if an incorrect number of parameters are passed.</exception>
  protected void AssignParameterValues(IDataParameter[] commandParameters, params object[] parameterValues)
  {
   if ((commandParameters == null) || (parameterValues == null))
   {
    // Do nothing if we get no data
    return;
   }
   // We must have the same number of values as we pave parameters to put them in
   if (commandParameters.Length != parameterValues.Length)
   {
    throw new ArgumentException("Parameter count does not match Parameter Value count.");
   }
   // Iterate through the IDataParameters, assigning the values from the corresponding position in the 
   // value array
   for (int i = 0, j = commandParameters.Length, k = 0; i < j; i++)
   {
    if (commandParameters[i].Direction != ParameterDirection.ReturnValue)
    {
     // If the current array value derives from IDataParameter, then assign its Value property
     if (parameterValues[k] is IDataParameter)
     {
      IDataParameter paramInstance;
      paramInstance = (IDataParameter)parameterValues[k];
      if (paramInstance.Direction == ParameterDirection.ReturnValue)
      {
       paramInstance = (IDataParameter)parameterValues[++k];
      }
      if (paramInstance.Value == null)
      {
       commandParameters[i].Value = DBNull.Value;
      }
      else
      {
       commandParameters[i].Value = paramInstance.Value;
      }
     }
     else if (parameterValues[k] == null)
     {
      commandParameters[i].Value = DBNull.Value;
     }
     else
     {
      commandParameters[i].Value = parameterValues[k];
     }
     k++;
    }
   }
  }
 }
}
Copier après la connexion
J'espère que cet article sera utile à la programmation C# de chacun.
Pour plus de méthodes basées sur C# pour accéder aux bases de données SQLite basées sur la classe SqlHelper de type SQLiteHelper et les articles associés, veuillez faire attention au site Web PHP chinois !