Click here to Skip to main content
Click here to Skip to main content
Articles » Database » Database » Databases » Downloads
 
Add your own
alternative version
Go to top

Stop writing connection management code every time you access the database

, 6 Jan 2006
A simple class library for database access without the pervasive and often-fragile connection management details.
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>AMS.ADO</name>
    </assembly>
    <members>
        <member name="T:AMS.ADO.ICommand">
            <summary>
              Generic representation of an SQL command to be executed against a database. </summary>
        </member>
        <member name="M:AMS.ADO.ICommand.ExecuteDataSet(System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              returns the results inside a DataSet object. </summary>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is a DataSet object. </returns>
        </member>
        <member name="M:AMS.ADO.ICommand.ExecuteDataSet(System.Data.DataSet,System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              appends the results to a DataSet object. </summary>
            <param name="ds">
              The DataSet object to be filled with the results of the cmd. </param>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is the same DataSet object passed in as a parameter. </returns>
        </member>
        <member name="M:AMS.ADO.ICommand.ExecuteString">
            <summary>
              Calls <see cref="M:System.Data.IDbCommand.ExecuteScalar"/> and casts the result to a string. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              converted to a string.  If the first column of the first row is DBNull.Value, the return
              value is an empty string.  If the result set is empty, the return value is null. </returns>
        </member>
        <member name="M:AMS.ADO.ICommand.ExecuteInt">
            <summary>
              Calls <see cref="M:System.Data.IDbCommand.ExecuteScalar"/> and casts the result to an int. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              cast to an int.  If the first column of the first row is DBNull.Value or cannot be
              converted to an int, the return value is 0.  If the result set is empty, 
              the return value is 0.  </returns>
        </member>
        <member name="P:AMS.ADO.ICommand.ConnectionString">
            <summary>
              Gets or sets the connection string to use when connecting to the 
              database where the command will be executed. </summary>
        </member>
        <member name="T:AMS.ADO.Odbc.SQL">
            <summary>
              Represents an SQL statement to be executed against an ODBC data source. </summary>
            <remarks>
              This class encapsulates the OdbcCommand class with the added convenience of connection 
              management.  It automatically opens the connection if it needs to, uses it, and closes
              it if it's no longer needed.  This can significantly cut down the amount of repetitive 
              code normally required for connection management and helps to ensure that a connection 
              is not left open inadvertently. </remarks>
        </member>
        <member name="F:AMS.ADO.Odbc.SQL.m_command">
            <summary>
              OdbcCommand object used for command execution. </summary>
        </member>
        <member name="F:AMS.ADO.Odbc.SQL.m_connectionWasOpen">
            <summary>
              Indicator of whether the connection is already open when the command gets executed
              so that it can be left alone when Dispose is called. </summary>
        </member>
        <member name="F:AMS.ADO.Odbc.SQL.m_connectionString">
            <summary>
              String used by the OdbcConnection object to connect to the database. </summary>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL();
                sql.ConnectionString = connectionString;
                sql.CommandText = "INSERT INTO ...";
                sql.Parameters.Add("?", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...");
                sql.ConnectionString = connectionString;
                sql.Parameters.Add("?", value);
                int count = sql.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the SQL object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT Description FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                string description = sql.ExecuteString(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.Data.Odbc.OdbcConnection)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OdbcCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OdbcConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("UPDATE ...", connection);
                sql.Parameters.Add("?", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.Data.Odbc.OdbcConnection,System.Data.Odbc.OdbcTransaction)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection and transaction to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OdbcCommand object
              that will execute the command. </param>
            <param name="transaction">
              The transaction object to be used by the internal OdbcCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OdbcConnection object and an OdbcTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection, transaction);
                sql.Parameters.Add("?", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.Connect">
            <summary>
              Opens the connection of the internal OdbcCommand object, based on
              the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> or connection previously set. </summary>
            <exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.Dispose">
            <summary>
              Disposes of the internal OdbcCommand object's connection, if it was created locally;
              otherwise it is left in the same state as it was found. </summary>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteReader">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteReader on the internal OdbcCommand object.</summary>
            <returns>
              The return value is an OdbcDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the OdbcDataReader
              object is closed. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                using (OdbcDataReader reader = sql.ExecuteReader())
                {
                  ...
                }  // disposes of reader and the query's connection </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#ExecuteReader">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <returns>
              The return value is an IDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the IDataReader
              object is closed. </remarks> 
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <param name="behavior">
              One of the CommandBehavior values. </param>
            <returns>
              The return value is an IDataReader object. </returns>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              returns the results inside a DataSet object. </summary>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is a DataSet object. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              appends the results to a DataSet object. </summary>
            <param name="ds">
              The DataSet object to be filled with the results of the sql. </param>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is the same DataSet object passed in as a parameter. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                DataSet ds = new DataSet();
                ...
                SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
                sql.Parameters.Add("?", value);
                sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteScalar">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteScalar on the internal OdbcCommand object.</summary>
            <returns>
              The return value is the first column of the first row in the result set, 
              or null if the result set is empty. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                int count = (int)sql.ExecuteScalar(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteString">
            <summary>
              Calls <see cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              converted to a string.  If the first column of the first row is DBNull.Value, the return
              value is an empty string.  If the result set is empty, the return value is null. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT name FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                string name = sql.ExecuteString(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteInt">
            <summary>
              Calls <see cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              cast to an int.  If the first column of the first row is DBNull.Value or cannot be
              converted to an int, the return value is 0.  If the result set is empty, 
              the return value is 0.  </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT age FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                int age = sql.ExecuteInt(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery">
            <summary>
              Opens a temporary database connection and executes the command by
              calling ExecuteNonQuery on the internal OdbcCommand object. </summary>
            <returns>
              The return value is the number of rows affected. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection);
                sql.Parameters.Add("?", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.Cancel">
            <summary>
              Attempts to cancels the execution of the internal OdbcCommand object. </summary>
            <remarks>
              If there is nothing to cancel, nothing happens. However, if there is a command 
              in process, and the attempt to cancel fails, no exception is generated. </remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.CreateParameter">
            <summary>
              Creates a new instance of an OdbcParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#CreateParameter">
            <summary>
              Creates a new instance of an IDbDataParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.Odbc.SQL.Prepare">
            <summary>
              Opens a database connection and creates a prepared 
              (or compiled) version of the command on the data source. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.CommandText">
            <summary>
              Gets or sets the text for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.CommandType">
            <summary>
              Gets or sets the type for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.CommandTimeout">
            <summary>
              Gets or sets the timeout for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.ConnectionString">
            <summary>
              Gets or sets the connection string to use when connecting to the 
              database where the command will be executed. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.Connection">
            <summary>
              Gets the OdbcConnection object associated with the internal OdbcCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Connection">
            <summary>
              Gets or sets the OdbcConnection object associated with the internal OdbcCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.Transaction">
            <summary>
              Gets the OdbcTransaction object associated with the internal OdbcCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Transaction">
            <summary>
              Gets or sets the OdbcTransaction object associated with the internal OdbcCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.Parameters">
            <summary>
              Gets the collection of OdbcParameter objects associated with the
              internal OdbcCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Parameters">
            <summary>
              Gets the collection of IDataParameter objects associated with the
              internal OdbcCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.Odbc.SQL.UpdatedRowSource">
            <summary>
              Gets or sets how command results are applied to the DataRow when 
              used by the Update method of a DbDataAdapter. </summary>
        </member>
        <member name="T:AMS.ADO.Odbc.StoredProcedure">
            <summary>
              Represents a stored procedure to be executed against an ODBC data source. </summary>
            <remarks>
              This class encapsulates the OdbcCommand class (configured to execute a stored procedure) 
              with the added convenience of connection management.  It automatically opens the connection 
              if it needs to, uses it, and closes it if it's no longer needed.  This can significantly cut 
              down the amount of repetitive code normally required for connection management and helps 
              to ensure that a connection is not left open inadvertently. </remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure();
                sp.ConnectionString = connectionString;
                sp.CommandText = "{call spGetEmployees(?)}";
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}");
                sp.ConnectionString = connectionString;
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the StoredProcedure object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connectionString);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.Data.Odbc.OdbcConnection)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OdbcCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OdbcConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connection);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.Data.Odbc.OdbcConnection,System.Data.Odbc.OdbcTransaction)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection and transaction to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OdbcCommand object
              that will execute the statement. </param>
            <param name="transaction">
              The transaction object to be used by the internal OdbcCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OdbcConnection object and an OdbcTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connection, transaction);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="T:AMS.ADO.OleDb.SQL">
            <summary>
              Represents an SQL statement to be executed against an OLEDB data source. </summary>
            <remarks>
              This class encapsulates the OleDbCommand class with the added convenience of connection 
              management.  It automatically opens the connection if it needs to, uses it, and closes
              it if it's no longer needed.  This can significantly cut down the amount of repetitive 
              code normally required for connection management and helps to ensure that a connection 
              is not left open inadvertently. </remarks>
        </member>
        <member name="F:AMS.ADO.OleDb.SQL.m_command">
            <summary>
              OleDbCommand object used for command execution. </summary>
        </member>
        <member name="F:AMS.ADO.OleDb.SQL.m_connectionWasOpen">
            <summary>
              Indicator of whether the connection is already open when the command gets executed
              so that it can be left alone when Dispose is called. </summary>
        </member>
        <member name="F:AMS.ADO.OleDb.SQL.m_connectionString">
            <summary>
              String used by the OleDbConnection object to connect to the database. </summary>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL();
                sql.ConnectionString = connectionString;
                sql.CommandText = "INSERT INTO ...";
                sql.Parameters.Add("?", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...");
                sql.ConnectionString = connectionString;
                sql.Parameters.Add("?", value);
                int count = sql.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the SQL object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT Description FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                string description = sql.ExecuteString(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.Data.OleDb.OleDbConnection)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OleDbCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OleDbConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("UPDATE ...", connection);
                sql.Parameters.Add("?", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbTransaction)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection and transaction to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OleDbCommand object
              that will execute the command. </param>
            <param name="transaction">
              The transaction object to be used by the internal OleDbCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OleDbConnection object and an OleDbTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection, transaction);
                sql.Parameters.Add("?", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.Connect">
            <summary>
              Opens the connection of the internal OleDbCommand object, based on
              the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> or connection previously set. </summary>
            <exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.Dispose">
            <summary>
              Disposes of the internal OleDbCommand object's connection, if it was created locally;
              otherwise it is left in the same state as it was found. </summary>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteReader">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteReader on the internal OleDbCommand object.</summary>
            <returns>
              The return value is an OleDbDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the OleDbDataReader
              object is closed. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                using (OleDbDataReader reader = sql.ExecuteReader())
                {
                  ...
                }  // disposes of reader and the query's connection </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#ExecuteReader">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <returns>
              The return value is an IDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the IDataReader
              object is closed. </remarks> 
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <param name="behavior">
              One of the CommandBehavior values. </param>
            <returns>
              The return value is an IDataReader object. </returns>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              returns the results inside a DataSet object. </summary>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is a DataSet object. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              appends the results to a DataSet object. </summary>
            <param name="ds">
              The DataSet object to be filled with the results of the sql. </param>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is the same DataSet object passed in as a parameter. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                DataSet ds = new DataSet();
                ...
                SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
                sql.Parameters.Add("?", value);
                sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteScalar">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteScalar on the internal OleDbCommand object.</summary>
            <returns>
              The return value is the first column of the first row in the result set, 
              or null if the result set is empty. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                int count = (int)sql.ExecuteScalar(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteString">
            <summary>
              Calls <see cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              converted to a string.  If the first column of the first row is DBNull.Value, the return
              value is an empty string.  If the result set is empty, the return value is null. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT name FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                string name = sql.ExecuteString(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteInt">
            <summary>
              Calls <see cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              cast to an int.  If the first column of the first row is DBNull.Value or cannot be
              converted to an int, the return value is 0.  If the result set is empty, 
              the return value is 0.  </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT age FROM ...", connectionString);
                sql.Parameters.Add("?", value);
                int age = sql.ExecuteInt(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery">
            <summary>
              Opens a temporary database connection and executes the command by
              calling ExecuteNonQuery on the internal OleDbCommand object. </summary>
            <returns>
              The return value is the number of rows affected. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection);
                sql.Parameters.Add("?", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.Cancel">
            <summary>
              Attempts to cancels the execution of the internal OleDbCommand object. </summary>
            <remarks>
              If there is nothing to cancel, nothing happens. However, if there is a command 
              in process, and the attempt to cancel fails, no exception is generated. </remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.CreateParameter">
            <summary>
              Creates a new instance of a OleDbParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#CreateParameter">
            <summary>
              Creates a new instance of an IDbDataParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.OleDb.SQL.Prepare">
            <summary>
              Opens a database connection and creates a prepared 
              (or compiled) version of the command on the data source. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.CommandText">
            <summary>
              Gets or sets the text for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.CommandType">
            <summary>
              Gets or sets the type for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.CommandTimeout">
            <summary>
              Gets or sets the timeout for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.ConnectionString">
            <summary>
              Gets or sets the connection string to use when connecting to the 
              database where the command will be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.Connection">
            <summary>
              Gets the OleDbConnection object associated with the internal OleDbCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Connection">
            <summary>
              Gets or sets the OleDbConnection object associated with the internal OleDbCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.Transaction">
            <summary>
              Gets the OleDbTransaction object associated with the internal OleDbCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Transaction">
            <summary>
              Gets or sets the OleDbTransaction object associated with the internal OleDbCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.Parameters">
            <summary>
              Gets the collection of OleDbParameter objects associated with the
              internal OleDbCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Parameters">
            <summary>
              Gets the collection of IDataParameter objects associated with the
              internal OleDbCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OleDb.SQL.UpdatedRowSource">
            <summary>
              Gets or sets how command results are applied to the DataRow when 
              used by the Update method of a DbDataAdapter. </summary>
        </member>
        <member name="T:AMS.ADO.OleDb.StoredProcedure">
            <summary>
              Represents a stored procedure to be executed against an OLEDB data source. </summary>
            <remarks>
              This class encapsulates the OleDbCommand class (configured to execute a stored procedure) 
              with the added convenience of connection management.  It automatically opens the connection 
              if it needs to, uses it, and closes it if it's no longer needed.  This can significantly cut 
              down the amount of repetitive code normally required for connection management and helps 
              to ensure that a connection is not left open inadvertently. </remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure();
                sp.ConnectionString = connectionString;
                sp.CommandText = "spGetEmployees";
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees");
                sp.ConnectionString = connectionString;
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the StoredProcedure object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.Data.OleDb.OleDbConnection)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OleDbCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OleDbConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbTransaction)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection and transaction to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OleDbCommand object
              that will execute the statement. </param>
            <param name="transaction">
              The transaction object to be used by the internal OleDbCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OleDbConnection object and an OleDbTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connection, transaction);
                sp.Parameters.Add("?", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="T:AMS.ADO.OracleClient.SQL">
            <summary>
              Represents an SQL statement to be executed against an Oracle database. </summary>
            <remarks>
              This class encapsulates the OracleCommand class with the added convenience of connection 
              management.  It automatically opens the connection if it needs to, uses it, and closes
              it if it's no longer needed.  This can significantly cut down the amount of repetitive 
              code normally required for connection management and helps to ensure that a connection 
              is not left open inadvertently. </remarks>
        </member>
        <member name="F:AMS.ADO.OracleClient.SQL.m_command">
            <summary>
              OracleCommand object used for command execution. </summary>
        </member>
        <member name="F:AMS.ADO.OracleClient.SQL.m_connectionWasOpen">
            <summary>
              Indicator of whether the connection is already open when the command gets executed
              so that it can be left alone when Dispose is called. </summary>
        </member>
        <member name="F:AMS.ADO.OracleClient.SQL.m_connectionString">
            <summary>
              String used by the OracleConnection object to connect to the database. </summary>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL();
                sql.ConnectionString = connectionString;
                sql.CommandText = "INSERT INTO ...";
                sql.Parameters.Add("P1", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...");
                sql.ConnectionString = connectionString;
                sql.Parameters.Add("P1", value);
                int count = sql.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the SQL object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT Description FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                string description = sql.ExecuteString(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.Data.OracleClient.OracleConnection)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OracleCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OracleConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("UPDATE ...", connection);
                sql.Parameters.Add("P1", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.Data.OracleClient.OracleConnection,System.Data.OracleClient.OracleTransaction)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection and transaction to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OracleCommand object
              that will execute the command. </param>
            <param name="transaction">
              The transaction object to be used by the internal OracleCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OracleConnection object and an OracleTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection, transaction);
                sql.Parameters.Add("P1", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.Connect">
            <summary>
              Opens the connection of the internal OracleCommand object, based on
              the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> or connection previously set. </summary>
            <exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.Dispose">
            <summary>
              Disposes of the internal OracleCommand object's connection, if it was created locally;
              otherwise it is left in the same state as it was found. </summary>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteReader">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteReader on the internal OracleCommand object.</summary>
            <returns>
              The return value is an OracleDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the OracleDataReader
              object is closed. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                using (OracleDataReader reader = sql.ExecuteReader())
                {
                  ...
                }  // disposes of reader and the query's connection </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#ExecuteReader">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <returns>
              The return value is an IDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the IDataReader
              object is closed. </remarks> 
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <param name="behavior">
              One of the CommandBehavior values. </param>
            <returns>
              The return value is an IDataReader object. </returns>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              returns the results inside a DataSet object. </summary>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is a DataSet object. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              appends the results to a DataSet object. </summary>
            <param name="ds">
              The DataSet object to be filled with the results of the sql. </param>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is the same DataSet object passed in as a parameter. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                DataSet ds = new DataSet();
                ...
                SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
                sql.Parameters.Add("P1", value);
                sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteScalar">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteScalar on the internal OracleCommand object.</summary>
            <returns>
              The return value is the first column of the first row in the result set, 
              or null if the result set is empty. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                int count = (int)sql.ExecuteScalar(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteString">
            <summary>
              Calls <see cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              converted to a string.  If the first column of the first row is DBNull.Value, the return
              value is an empty string.  If the result set is empty, the return value is null. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT name FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                string name = sql.ExecuteString(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteInt">
            <summary>
              Calls <see cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              cast to an int.  If the first column of the first row is DBNull.Value or cannot be
              converted to an int, the return value is 0.  If the result set is empty, 
              the return value is 0.  </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT age FROM ...", connectionString);
                sql.Parameters.Add("P1", value);
                int age = sql.ExecuteInt(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery">
            <summary>
              Opens a temporary database connection and executes the command by
              calling ExecuteNonQuery on the internal OracleCommand object. </summary>
            <returns>
              The return value is the number of rows affected. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection);
                sql.Parameters.Add("P1", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.Cancel">
            <summary>
              Attempts to cancels the execution of the internal OracleCommand object. </summary>
            <remarks>
              If there is nothing to cancel, nothing happens. However, if there is a command 
              in process, and the attempt to cancel fails, no exception is generated. </remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.CreateParameter">
            <summary>
              Creates a new instance of a OracleParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#CreateParameter">
            <summary>
              Creates a new instance of an IDbDataParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.OracleClient.SQL.Prepare">
            <summary>
              Opens a database connection and creates a prepared 
              (or compiled) version of the command on the data source. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.CommandText">
            <summary>
              Gets or sets the text for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.CommandType">
            <summary>
              Gets or sets the type for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#CommandTimeout">
            <summary>
              Gets or sets the timeout for the command to be executed. </summary>
            <remarks>
              Note: This property is not part of OracleCommand until .NET 2.0. </remarks>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.ConnectionString">
            <summary>
              Gets or sets the connection string to use when connecting to the 
              database where the command will be executed. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.Connection">
            <summary>
              Gets the OracleConnection object associated with the internal OracleCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Connection">
            <summary>
              Gets or sets the OracleConnection object associated with the internal OracleCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.Transaction">
            <summary>
              Gets the OracleTransaction object associated with the internal OracleCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Transaction">
            <summary>
              Gets or sets the OracleTransaction object associated with the internal OracleCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.Parameters">
            <summary>
              Gets the collection of OracleParameter objects associated with the
              internal OracleCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Parameters">
            <summary>
              Gets the collection of IDataParameter objects associated with the
              internal OracleCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.OracleClient.SQL.UpdatedRowSource">
            <summary>
              Gets or sets how command results are applied to the DataRow when 
              used by the Update method of a DbDataAdapter. </summary>
        </member>
        <member name="T:AMS.ADO.OracleClient.StoredProcedure">
            <summary>
              Represents a stored procedure to be executed against an Oracle database. </summary>
            <remarks>
              This class encapsulates the OracleCommand class (configured to execute a stored procedure) 
              with the added convenience of connection management.  It automatically opens the connection 
              if it needs to, uses it, and closes it if it's no longer needed.  This can significantly cut 
              down the amount of repetitive code normally required for connection management and helps 
              to ensure that a connection is not left open inadvertently. </remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure();
                sp.ConnectionString = connectionString;
                sp.CommandText = "spGetEmployees";
                sp.Parameters.Add("P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees");
                sp.ConnectionString = connectionString;
                sp.Parameters.Add("P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the StoredProcedure object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
                sp.Parameters.Add("P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.Data.OracleClient.OracleConnection)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OracleCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OracleConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
                sp.Parameters.Add("P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.Data.OracleClient.OracleConnection,System.Data.OracleClient.OracleTransaction)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection and transaction to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal OracleCommand object
              that will execute the statement. </param>
            <param name="transaction">
              The transaction object to be used by the internal OracleCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              OracleConnection object and an OracleTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connection, transaction);
                sp.Parameters.Add("P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="T:AMS.ADO.SqlClient.SQL">
            <summary>
              Represents an SQL statement to be executed against an SQL Server database. </summary>
            <remarks>
              This class encapsulates the SqlCommand class with the added convenience of connection 
              management.  It automatically opens the connection if it needs to, uses it, and closes
              it if it's no longer needed.  This can significantly cut down the amount of repetitive 
              code normally required for connection management and helps to ensure that a connection 
              is not left open inadvertently. </remarks>
        </member>
        <member name="F:AMS.ADO.SqlClient.SQL.m_command">
            <summary>
              SqlCommand object used for command execution. </summary>
        </member>
        <member name="F:AMS.ADO.SqlClient.SQL.m_connectionWasOpen">
            <summary>
              Indicator of whether the connection is already open when the command gets executed
              so that it can be left alone when Dispose is called. </summary>
        </member>
        <member name="F:AMS.ADO.SqlClient.SQL.m_connectionString">
            <summary>
              String used by the SqlConnection object to connect to the database. </summary>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL();
                sql.ConnectionString = connectionString;
                sql.CommandText = "INSERT INTO ...";
                sql.Parameters.Add("@P1", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...");
                sql.ConnectionString = connectionString;
                sql.Parameters.Add("@P1", value);
                int count = sql.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the SQL object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT Description FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                string description = sql.ExecuteString(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.Data.SqlClient.SqlConnection)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal SqlCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              SqlConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("UPDATE ...", connection);
                sql.Parameters.Add("@P1", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection and transaction to use. </summary>
            <param name="sql">
              The text for the command to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal SqlCommand object
              that will execute the command. </param>
            <param name="transaction">
              The transaction object to be used by the internal SqlCommand object
              that will execute the command. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              SqlConnection object and an SqlTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection, transaction);
                sql.Parameters.Add("@P1", value);
                sql.ExecuteNonQuery(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.Connect">
            <summary>
              Opens the connection of the internal SqlCommand object, based on
              the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> or connection previously set. </summary>
            <exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.Dispose">
            <summary>
              Disposes of the internal SqlCommand object's connection, if it was created locally;
              otherwise it is left in the same state as it was found. </summary>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteReader">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteReader on the internal SqlCommand object.</summary>
            <returns>
              The return value is an SqlDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the SqlDataReader
              object is closed. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                using (SqlDataReader reader = sql.ExecuteReader())
                {
                  ...
                }  // disposes of reader and the query's connection </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#ExecuteReader">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <returns>
              The return value is an IDataReader object. </returns>
            <remarks>
              If a temporary connection is created or a connection was passed in 
              a Closed state, it will be automatically closed when the IDataReader
              object is closed. </remarks> 
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
            <summary>
              Opens a database connection and executes the query by
              calling ExecuteReader on the internal IDbCommand object.</summary>
            <param name="behavior">
              One of the CommandBehavior values. </param>
            <returns>
              The return value is an IDataReader object. </returns>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              returns the results inside a DataSet object. </summary>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is a DataSet object. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT * FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
            <summary>
              Opens a temporary database connection, executes the query, and 
              appends the results to a DataSet object. </summary>
            <param name="ds">
              The DataSet object to be filled with the results of the sql. </param>
            <param name="tables">
              The array of names of the source tables to use for table mapping. </param>
            <returns>
              The return value is the same DataSet object passed in as a parameter. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                DataSet ds = new DataSet();
                ...
                SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
                sql.Parameters.Add("@P1", value);
                sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteScalar">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteScalar on the internal SqlCommand object.</summary>
            <returns>
              The return value is the first column of the first row in the result set, 
              or null if the result set is empty. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                int count = (int)sql.ExecuteScalar(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteString">
            <summary>
              Calls <see cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              converted to a string.  If the first column of the first row is DBNull.Value, the return
              value is an empty string.  If the result set is empty, the return value is null. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT name FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                string name = sql.ExecuteString(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteInt">
            <summary>
              Calls <see cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
            <returns>
              The return value is the first column of the first row in the result set
              cast to an int.  If the first column of the first row is DBNull.Value or cannot be
              converted to an int, the return value is 0.  If the result set is empty, 
              the return value is 0.  </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("SELECT age FROM ...", connectionString);
                sql.Parameters.Add("@P1", value);
                int age = sql.ExecuteInt(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery">
            <summary>
              Opens a temporary database connection and executes the command by
              calling ExecuteNonQuery on the internal SqlCommand object. </summary>
            <returns>
              The return value is the number of rows affected. </returns>
            <remarks>
              If a temporary connection is created, it is automatically disposed of; otherwise
              it is opened and left in the same state as it was found. 
              <example>Here's an example of its usage:
              <code> 
                SQL sql = new SQL("INSERT INTO ...", connection);
                sql.Parameters.Add("@P1", value);
                int rows = sql.ExecuteNonQuery(); </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.ExecuteXmlReader">
            <summary>
              Opens a temporary database connection and executes the query by
              calling ExecuteXmlReader on the internal SqlCommand object.</summary>
            <returns>
              The return value is an XmlReader object. </returns>
            <remarks>
              If a connection is created internally or a connection object was passed in 
              a Closed state, it will be automatically closed when the SqlDataReader
              object is closed. 
              <example>Here's an example of its usage:
              <code> 
                using (SQL sql = new SQL("SELECT * FROM ... FOR XML AUTO", connectionString))
                {
                  sql.Parameters.Add("@P1", value);
                  using (XmlReader reader = sql.ExecuteXmlReader())
                  {
                    ...
                  } // disposed of reader 
                } // disposed of the query's connection </code></example></remarks>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
            <seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.Cancel">
            <summary>
              Attempts to cancels the execution of the internal SqlCommand object. </summary>
            <remarks>
              If there is nothing to cancel, nothing happens. However, if there is a command 
              in process, and the attempt to cancel fails, no exception is generated. </remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.CreateParameter">
            <summary>
              Creates a new instance of a SqlParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#CreateParameter">
            <summary>
              Creates a new instance of an IDbDataParameter object. </summary>        
        </member>
        <member name="M:AMS.ADO.SqlClient.SQL.Prepare">
            <summary>
              Opens a database connection and creates a prepared 
              (or compiled) version of the command on the data source. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.CommandText">
            <summary>
              Gets or sets the text for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.CommandType">
            <summary>
              Gets or sets the type for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.CommandTimeout">
            <summary>
              Gets or sets the timeout for the command to be executed. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.ConnectionString">
            <summary>
              Gets or sets the connection string to use when connecting to the 
              database where the command will be executed. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.Connection">
            <summary>
              Gets the SqlConnection object associated with the internal SqlCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Connection">
            <summary>
              Gets or sets the SqlConnection object associated with the internal SqlCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.Transaction">
            <summary>
              Gets the SqlTransaction object associated with the internal SqlCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Transaction">
            <summary>
              Gets the SqlTransaction object associated with the internal SqlCommand 
              object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.Parameters">
            <summary>
              Gets the collection of SqlParameter objects associated with the
              internal SqlCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Parameters">
            <summary>
              Gets the collection of IDataParameter objects associated with the
              internal SqlCommand object used to execute the command. </summary>
        </member>
        <member name="P:AMS.ADO.SqlClient.SQL.UpdatedRowSource">
            <summary>
              Gets or sets how command results are applied to the DataRow when 
              used by the Update method of a DbDataAdapter. </summary>
        </member>
        <member name="T:AMS.ADO.SqlClient.StoredProcedure">
            <summary>
              Represents a stored procedure to be executed against an SQL Server database. </summary>
            <remarks>
              This class encapsulates the SqlCommand class (configured to execute a stored procedure) 
              with the added convenience of connection management.  It automatically opens the connection 
              if it needs to, uses it, and closes it if it's no longer needed.  This can significantly cut 
              down the amount of repetitive code normally required for connection management and helps 
              to ensure that a connection is not left open inadvertently. </remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor">
            <summary>
              Constructs the object. </summary>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.CommandText"/> 
              and <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> properties be set before the command 
              can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure();
                sp.ConnectionString = connectionString;
                sp.CommandText = "SELECT COUNT(*) FROM ...";
                sp.Parameters.Add("@P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String)">
            <summary>
              Constructs the object and sets the text for the command. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <remarks>
              Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> 
              property be set before the command can be executed. 
              <example>Here's an example:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees");
                sp.ConnectionString = connectionString;
                sp.Parameters.Add("@P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.String)">
            <summary>
              Constructs the object and sets the text for the command
              and the connection string. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connectionString">
              The connection string to use when connecting to the database where
              the command will be executed. </param>
            <remarks>
              This constructor offers the most convenient way to create the StoredProcedure object.  The
              SQL and connection string are passed together and commands may then be executed
              without worrying about connection management issues.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
                sp.Parameters.Add("@P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.Data.SqlClient.SqlConnection)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal SqlCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              SqlConnection object is already available.  The SQL object will automatically
              open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
                sp.Parameters.Add("@P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
        <member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction)">
            <summary>
              Constructs the object and sets the text for the statement
              and the connection and transaction to use. </summary>
            <param name="name">
              The name of the stored procedure to be executed. </param>
            <param name="connection">
              The connection object to be used by the internal SqlCommand object
              that will execute the statement. </param>
            <param name="transaction">
              The transaction object to be used by the internal SqlCommand object
              that will execute the statement. </param>
            <remarks>
              This constructor offers a convenient way to create the SQL object when an
              SqlConnection object and an SqlTransaction object are already available.  The SQL 
              object will automatically open the connection if necessary and return it to its original state when finished with it.
              After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to 
              assign values to any of its parameters and one of the Execute 
              methods to run it.
              <example>Here's an example of its usage:
              <code> 
                StoredProcedure sp = new StoredProcedure("SELECT COUNT(*) FROM ...", connection, transaction);
                sp.Parameters.Add("@P1", value);
                int count = sp.ExecuteInt(); </code></example></remarks>
        </member>
    </members>
</doc>

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Alvaro Mendez
Web Developer
United States United States
I've done extensive work with C++, MFC, COM, and ATL on the Windows side. On the Web side, I've worked with VB, ASP, JavaScript, and COM+. I've also been involved with server-side Java, which includes JSP, Servlets, and EJB, and more recently with ASP.NET/C#.

| Advertise | Privacy | Mobile
Web03 | 2.8.140916.1 | Last Updated 6 Jan 2006
Article Copyright 2006 by Alvaro Mendez
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid