C# MySQL Helper

using System;using System.Configuration;using System.Data;using System.Xml;using System.Data.SqlClient;using System.Collections;using MySQLDriverCS;/// <summary>/// The SqlHelper class is intended to encapsulate high performance, scalable best practices for /// common uses of SqlClient./// </summary>public sealed class SqlHelper{    #region private utility methods & constructors    //Since this class provides only static methods, make the default constructor private to prevent     //instances from being created with "new SqlHelper()".    private SqlHelper() { }    /// <summary>    /// This method is used to attach array of MySQLParameters to a MySQLCommand.    ///     /// This method will assign a value of DbNull to any parameter with a direction of    /// InputOutput and a value of null.      ///     /// This behavior will prevent default values from being used, but    /// this will be the less common case than an intended pure output parameter (derived as InputOutput)    /// where the user provided no input value.    /// </summary>    /// <param name="command">The command to which the parameters will be added</param>    /// <param name="commandParameters">an array of MySQLParameters tho be added to command</param>    private static void AttachParameters(MySQLCommand command, MySQLParameter[] commandParameters)    {        foreach (MySQLParameter p in commandParameters)        {            //check for derived output value with no value assigned            if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))            {                p.Value = DBNull.Value;            }            command.Parameters.Add(p);        }    }    /// <summary>    /// This method assigns an array of values to an array of MySQLParameters.    /// </summary>    /// <param name="commandParameters">array of MySQLParameters to be assigned values</param>    /// <param name="parameterValues">array of Components holding the values to be assigned</param>    private static void AssignParameterValues(MySQLParameter[] commandParameters, 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("参数与值数量不匹配.");        }        //iterate through the MySQLParameters, assigning the values from the corresponding position in the         //value array        for (int i = 0, j = commandParameters.Length; i < j; i++)        {            commandParameters[i].Value = parameterValues[i];        }    }    /// <summary>    /// This method opens (if necessary) and assigns a connection, transaction, command type and parameters     /// to the provided command.    /// </summary>    /// <param name="command">the MySQLCommand to be prepared</param>    /// <param name="connection">a valid MySQLConnection, on which to execute this command</param>    /// <param name="transaction">a valid MySQLTransaction, or 'null'</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of MySQLParameters to be associated with the command or 'null' if no parameters are required</param>    ///     private static void PrepareCommand(MySQLCommand command, MySQLConnection connection, MySQLTransaction transaction, CommandType commandType, string commandText, MySQLParameter[] commandParameters)    {                //if the provided connection is not open, we will open it        if (connection.State != ConnectionState.Open)        {            connection.Open();        }        //associate the connection with the command        command.Connection = connection;        //set the command text (stored procedure name or SQL statement)        command.CommandText = commandText;        //if we were provided a transaction, assign it.        if (transaction != null)        {            command.Transaction = transaction;        }        //set the command type        command.CommandType = commandType;        //attach the command parameters if they are provided        if (commandParameters != null)        {            AttachParameters(command, commandParameters);        }        return;    }    #endregion private utility methods & constructors    #region DataHelpers    public static string CheckNull(object obj)    {        return (string)obj;    }    public static string CheckNull(DBNull obj)    {        return null;    }    #endregion    #region AddParameters    public static object CheckForNullString(string text)    {        if (text == null || text.Trim().Length == 0)        {            return System.DBNull.Value;        }        else        {            return text;        }    }    public static MySQLParameter MakeInParam(string ParamName, object Value)    {        return new MySQLParameter(ParamName, Value);    }    /// <summary>    /// Make input param.    /// </summary>    /// <param name="ParamName">Name of param.</param>    /// <param name="DbType">Param type.</param>    /// <param name="Size">Param size.</param>    /// <param name="Value">Param value.</param>    /// <returns>New parameter.</returns>    public static MySQLParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value)    {        return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value);    }    /// <summary>    /// Make input param.    /// </summary>    /// <param name="ParamName">Name of param.</param>    /// <param name="DbType">Param type.</param>    /// <param name="Size">Param size.</param>    /// <returns>New parameter.</returns>    public static MySQLParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size)    {        return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null);    }    /// <summary>    /// Make stored procedure param.    /// </summary>    /// <param name="ParamName">Name of param.</param>    /// <param name="DbType">Param type.</param>    /// <param name="Size">Param size.</param>    /// <param name="Direction">Parm direction.</param>    /// <param name="Value">Param value.</param>    /// <returns>New parameter.</returns>    public static MySQLParameter MakeParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)    {        MySQLParameter param;        if (Size > 0)            param = new MySQLParameter(ParamName, (DbType)DbType, Size.ToString());        else            param = new MySQLParameter(ParamName, DbType);        param.Direction = Direction;        if (!(Direction == ParameterDirection.Output && Value == null))            param.Value = Value;        return param;    }    #endregion    #region ExecuteNonQuery    /// <summary>    /// Execute a MySQLCommand (that returns no resultset and takes no parameters) against the database specified in     /// the connection string.     /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteNonQuery(connectionString, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns no resultset) against the database specified in the connection string     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create & open a MySQLConnection, and dispose of it after we are done.        using (MySQLConnection cn = new MySQLConnection(connectionString))        {            cn.Open();            //call the overload that takes a connection in place of the connection string            return ExecuteNonQuery(cn, commandType, commandText, commandParameters);        }    }    /// <summary>    /// Execute a MySQLCommand (that returns no resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(MySQLConnection connection, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteNonQuery(connection, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns no resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, connection, (MySQLTransaction)null, commandType, commandText, commandParameters);        //finally, execute the command.        int retval = cmd.ExecuteNonQuery();        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        return retval;    }    /// <summary>    /// Execute a MySQLCommand (that returns no resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(MySQLTransaction transaction, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteNonQuery(transaction, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns no resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an int representing the number of rows affected by the command</returns>    public static int ExecuteNonQuery(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, (MySQLConnection)transaction.Connection, transaction, commandType, commandText, commandParameters);        //finally, execute the command.        int retval = cmd.ExecuteNonQuery();        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        return retval;    }    #endregion ExecuteNonQuery    #region ExecuteDataSet    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the database specified in     /// the connection string.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataset(connectionString, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the database specified in the connection string     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create & open a MySQLConnection, and dispose of it after we are done.        using (MySQLConnection cn = new MySQLConnection(connectionString))        {            cn.Open();            //call the overload that takes a connection in place of the connection string            return ExecuteDataset(cn, commandType, commandText, commandParameters);        }    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(MySQLConnection connection, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataset(connection, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, connection, (MySQLTransaction)null, commandType, commandText, commandParameters);        //create the DataAdapter & DataSet        MySQLDataAdapter da = new MySQLDataAdapter(cmd);        DataSet ds = new DataSet();                //fill the DataSet using default values for DataTable names, etc.        da.Fill(ds);        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        //return the dataset        return ds;    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(MySQLTransaction transaction, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataset(transaction, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a dataset containing the resultset generated by the command</returns>    public static DataSet ExecuteDataset(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, (MySQLConnection)transaction.Connection, transaction, commandType, commandText, commandParameters);        //create the DataAdapter & DataSet        MySQLDataAdapter da = new MySQLDataAdapter(cmd);        DataSet ds = new DataSet();        //fill the DataSet using default values for DataTable names, etc.        da.Fill(ds);        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        //return the dataset        return ds;    }    #endregion ExecuteDataSet    #region ExecuteDataTable    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the database specified in     /// the connection string.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(connString, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataTable(connectionString, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the database specified in the connection string     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(connString, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create & open a MySQLConnection, and dispose of it after we are done.        using (MySQLConnection cn = new MySQLConnection(connectionString))        {            cn.Open();            //call the overload that takes a connection in place of the connection string            return ExecuteDataTable(cn, commandType, commandText, commandParameters);        }    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(conn, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(MySQLConnection connection, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataTable(connection, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(conn, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, connection, (MySQLTransaction)null, commandType, commandText, commandParameters);        //create the DataAdapter & DataTable        MySQLDataAdapter da = new MySQLDataAdapter(cmd);        DataTable dt = new DataTable();        //fill the DataTable using default values for DataTable names, etc.        da.Fill(dt);        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        //return the DataTable        return dt;    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(trans, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(MySQLTransaction transaction, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteDataTable(transaction, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  DataTable dt = ExecuteDataTable(trans, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a DataTable containing the resultset generated by the command</returns>    public static DataTable ExecuteDataTable(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, (MySQLConnection)transaction.Connection, transaction, commandType, commandText, commandParameters);        //create the DataAdapter & DataTable        MySQLDataAdapter da = new MySQLDataAdapter(cmd);        DataTable dt = new DataTable();        //fill the DataTable using default values for DataTable names, etc.        da.Fill(dt);        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        //return the DataTable        return dt;    }    #endregion ExecuteDataTable    #region ExecuteReader    /// <summary>    /// this enum is used to indicate whether the connection was provided by the caller, or created by SqlHelper, so that    /// we can set the appropriate CommandBehavior when calling ExecuteReader()    /// </summary>    private enum MySQLConnectionOwnership    {        /// <summary>Connection is owned and managed by SqlHelper</summary>        Internal,        /// <summary>Connection is owned and managed by the caller</summary>        External    }    /// <summary>    /// Create and prepare a MySQLCommand, and call ExecuteReader with the appropriate CommandBehavior.    /// </summary>    /// <remarks>    /// If we created and opened the connection, we want the connection to be closed when the DataReader is closed.    ///     /// If the caller provided the connection, we want to leave it to them to manage.    /// </remarks>    /// <param name="connection">a valid MySQLConnection, on which to execute this command</param>    /// <param name="transaction">a valid MySQLTransaction, or 'null'</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of MySQLParameters to be associated with the command or 'null' if no parameters are required</param>    /// <param name="connectionOwnership">indicates whether the connection parameter was provided by the caller, or created by SqlHelper</param>    /// <returns> MySQLDataReader containing the results of the command</returns>    private static  MySQLDataReader ExecuteReader(MySQLConnection connection, MySQLTransaction transaction, CommandType commandType, string commandText, MySQLParameter[] commandParameters, MySQLConnectionOwnership connectionOwnership)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);        //create a reader         MySQLDataReader dr;               // call ExecuteReader with the appropriate CommandBehavior        if (connectionOwnership == MySQLConnectionOwnership.External)        {            dr = (MySQLDataReader)cmd.ExecuteReader();        }        else        {            dr = (MySQLDataReader)cmd.ExecuteReader(CommandBehavior.CloseConnection);        }        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        return dr;    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the database specified in     /// the connection string.     /// </summary>    /// <remarks>    /// e.g.:      ///   MySQLDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteReader(connectionString, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the database specified in the connection string     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///   MySQLDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create & open a MySQLConnection        MySQLConnection cn = new MySQLConnection(connectionString);        cn.Open();        try        {            //call the private overload that takes an internally owned connection in place of the connection string            return ExecuteReader(cn, null, commandType, commandText, commandParameters, MySQLConnectionOwnership.Internal);        }        catch        {            //if we fail to return the SqlDatReader, we need to close the connection ourselves            cn.Close();            throw;        }    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///   MySQLDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(MySQLConnection connection, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteReader(connection, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///   MySQLDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //pass through the call to the private overload using a null transaction value and an externally owned connection        return ExecuteReader(connection, (MySQLTransaction)null, commandType, commandText, commandParameters, MySQLConnectionOwnership.External);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///   MySQLDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(MySQLTransaction transaction, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteReader(transaction, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///    MySQLDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>a  MySQLDataReader containing the resultset generated by the command</returns>    public static  MySQLDataReader ExecuteReader(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //pass through to private overload, indicating that the connection is owned by the caller        return ExecuteReader((MySQLConnection)transaction.Connection, transaction, commandType, commandText, commandParameters, MySQLConnectionOwnership.External);    }    #endregion ExecuteReader    #region ExecuteScalar    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in     /// the connection string.     /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteScalar(connectionString, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset) against the database specified in the connection string     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connectionString">a valid connection string for a MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create & open a MySQLConnection, and dispose of it after we are done.        using (MySQLConnection cn = new MySQLConnection(connectionString))        {            cn.Open();            //call the overload that takes a connection in place of the connection string            return ExecuteScalar(cn, commandType, commandText, commandParameters);        }    }    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(MySQLConnection connection, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteScalar(connection, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, connection, (MySQLTransaction)null, commandType, commandText, commandParameters);        //execute the command & return the results        object retval = cmd.ExecuteScalar();        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        return retval;    }    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(MySQLTransaction transaction, CommandType commandType, string commandText)    {        //pass through the call providing null for the set of MySQLParameters        return ExecuteScalar(transaction, commandType, commandText, (MySQLParameter[])null);    }    /// <summary>    /// Execute a MySQLCommand (that returns a 1x1 resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>    public static object ExecuteScalar(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    {        //create a command and prepare it for execution        MySQLCommand cmd = new MySQLCommand();        PrepareCommand(cmd, (MySQLConnection)transaction.Connection, transaction, commandType, commandText, commandParameters);        //execute the command & return the results        object retval = cmd.ExecuteScalar();        // detach the MySQLParameters from the command object, so they can be used again.        cmd.Parameters.Clear();        return retval;    }    #endregion ExecuteScalar    #region ExecuteXmlReader    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLConnection.     /// </summary>    /// <remarks>    /// e.g.:      ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command using "FOR XML AUTO"</param>    /// <returns>an XmlReader containing the resultset generated by the command</returns>    //public static XmlReader ExecuteXmlReader(MySQLConnection connection, CommandType commandType, string commandText)    //{        //pass through the call providing null for the set of MySQLParameters       // return ExecuteXmlReader(connection, commandType, commandText, (MySQLParameter[])null);    //}    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLConnection     /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="connection">a valid MySQLConnection</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command using "FOR XML AUTO"</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an XmlReader containing the resultset generated by the command</returns>    //public static XmlReader ExecuteXmlReader(MySQLConnection connection, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    //{    //    //create a command and prepare it for execution    //    MySQLCommand cmd = new MySQLCommand();    //    PrepareCommand(cmd, connection, (MySQLTransaction)null, commandType, commandText, commandParameters);    //    //create the DataAdapter & DataSet    //    XmlReader retval = cmd.ExecuteXmlReader();    //    // detach the MySQLParameters from the command object, so they can be used again.    //    cmd.Parameters.Clear();    //    return retval;    //}    /// <summary>    /// Execute a MySQLCommand (that returns a resultset and takes no parameters) against the provided MySQLTransaction.     /// </summary>    /// <remarks>    /// e.g.:      ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command using "FOR XML AUTO"</param>    /// <returns>an XmlReader containing the resultset generated by the command</returns>    //public static XmlReader ExecuteXmlReader(MySQLTransaction transaction, CommandType commandType, string commandText)    //{        //pass through the call providing null for the set of MySQLParameters      //  return ExecuteXmlReader(transaction, commandType, commandText, (MySQLParameter[])null);    //}    /// <summary>    /// Execute a MySQLCommand (that returns a resultset) against the specified MySQLTransaction    /// using the provided parameters.    /// </summary>    /// <remarks>    /// e.g.:      ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new MySQLParameter("@prodid", 24));    /// </remarks>    /// <param name="transaction">a valid MySQLTransaction</param>    /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>    /// <param name="commandText">the stored procedure name or T-SQL command using "FOR XML AUTO"</param>    /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>    /// <returns>an XmlReader containing the resultset generated by the command</returns>    //public static XmlReader ExecuteXmlReader(MySQLTransaction transaction, CommandType commandType, string commandText, params MySQLParameter[] commandParameters)    //{    //    //create a command and prepare it for execution    //    MySQLCommand cmd = new MySQLCommand();    //    PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);    //    //create the DataAdapter & DataSet    //    XmlReader retval = cmd.ExecuteXmlReader();    //    // detach the MySQLParameters from the command object, so they can be used again.    //    cmd.Parameters.Clear();    //    return retval;    //}    #endregion ExecuteXmlReader    #region myself methods    public static MySQLConnection GetConnection(String connectionString)    {        MySQLConnection cn = new MySQLConnection(connectionString);        cn.Open();        return cn;    }    #endregion mysel methods}