We Keep Coding

Getting The SqlParameter is already contained by another SqlParameterCollection error with c# / ASP.net app

I have a generic method which is adding parameters to a cmd.parameters collection. I am getting the following error when 2 people are hitting the same stored procedure at the same time:
The SqlParameter is already contained by another SqlParameterCollection.
I have already searched within StackOverflow and also elsewhere on the web but so far I am not able to rectify the problem. My code is as follows:
protected DataSet ExecuteDataSet(string StoredProcName, List<TParameter> Params) {
bool internalOpen = false;
DataSet resultDataSet = null;
TDataAdapter dataAdapter;
TCommand cmd;
try {
resultDataSet = new DataSet();
dataAdapter = new TDataAdapter();
cmd = new TCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = StoredProcName;
if (transaction != null) {
cmd.Transaction = transaction;
cmd.Connection = transaction.Connection;
} else {
cmd.Connection = connection;
}
if (Params != null && Params.Count > 0) {
foreach (TParameter param in Params) {
cmd.Parameters.Add(param);
}
}
dataAdapter.SelectCommand = cmd;
if (connection.State == ConnectionState.Closed) {
connection.Open();
internalOpen = true;
}
dataAdapter.Fill(resultDataSet);
dataAdapter.SelectCommand.Parameters.Clear();
cmd.Parameters.Clear();
return resultDataSet;
} catch {
throw;
} finally {
if (internalOpen) {
connection.Close();
}
}
The error is happening during the foreach loop but despite clearing parameters and applying some other attempted fixes I have been unable to prevent this error from happening.
This is being called from another method using the following:
result = base.ExecuteDataSet(procName,this.ConvertArrayList(this.ParamsList));
It is an older c# / asp.net (web forms) application that I am using, so the code reflects this.
The error message begins like so:
[ArgumentException: The SqlParameter is already contained by another SqlParameterCollection.]
System.Data.SqlClient.SqlParameterCollection.Validate(Int32 index, Object value) +5955779
System.Data.SqlClient.SqlParameterCollection.Add(Object value) +34
I am testing using 2 browsers logging in as 2 users at the same time and clicking a link to a page which pulls multiple records. One of these users gets the error while the other gets the correct page with returned results as expected.
Any help would be appreciated. Apologies if I haven't explained this well enough but I've been looking at this all day and haven't been able to progress.
Thanks in advance.
EDIT:
The ParamsList is set/get like this:
public ArrayList ParamsList {
get {
//Check to see if the parameters list has been initialised.
if (m_paramsList == null) {
//Create a new empty parameters list to pass back.
m_paramsList = new ArrayList();
}
return m_paramsList;
}
set {
m_paramsList = value;
}
}
And populated like so:
internal void AddParameter(string name, string value) {
IDbDataParameter param = CreateStringParameter(name);
param.Value = GetValueFromString(value);
Dal.ParamsList.Add(param);
}
for every type of parameter type....
internal void AddParameter(string name, double? value) {
internal void AddParameter(string name, byte[] value) {
etc...

Looking through the code in the question... a lot of it didn't accomplish what the author likely intended. The try/catch/finally, for example, was completely worthless because the catch block just re-threw the same exception and using the Fill() method meant the finally block was not needed. Other code has similar issues.
Except for the transactions, you could reduce the code down to just this, assuming TCommand and company fully implement the ADO.Net providers, where the reduced code actually increases performance, safety, and utility:
protected DataSet ExecuteDataSet(string StoredProcName, IEnumerable<TParameter> Params = null)
{
DataSet resultDataSet = new DataSet();
using (var cn = new TConnection(connection.ConnectionString))
using (var cmd = new TCommand(StoredProcName, cn))
using (var adapter = new TAdapter(cmd))
{
cmd.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach (TParameter param in Params)
{
cmd.Parameters.Add(param);
}
}
adapter.Fill(resultDataSet);
}
return resultDataSet;
}
But we do have that transaction value, and that's enough to break the using pattern here. Because of that, you'll want to effectively double the code length, to account for both variants. Yes, the using pattern really is that important, that you would effectively double the code length to keep it where possible:
protected DataSet ExecuteDataSet(string StoredProcName, IEnumerable<TParameter> Params = null)
{
DataSet resultDataSet = new DataSet();
if (transaction == null)
{
using (var cn = new TConnection(connection.ConnectionString))
using (var cmd = new TCommand(StoredProcName, cn))
using (var adapter = new TAdapter(cmd))
{
cmd.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach (TParameter param in Params)
{
cmd.Parameters.Add(param);
}
}
adapter.Fill(resultDataSet);
}
}
else
{
using (var cmd = new TCommand(StoredProcName, transaction.Connection))
using (var adapter = new TAdapter(cmd))
{
cmd.Transaction = transaction;
cmd.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach (TParameter param in Params)
{
cmd.Parameters.Add(param);
}
}
adapter.Fill(resultDataSet);
}
}
return resultDataSet;
}
Finally, none of this will fix your problem. The problem you're seeing is caused by code elsewhere trying too hard to re-use Parameter objects. You'll need to look at other code to fix the issue.

I am guessing that TCommand is a type of SqlCommand, and TParameter is a type of SqlParameter. I think the problem is here:
foreach (TParameter param in Params) {
cmd.Parameters.Add(param);
}
param is a member of Params, which is a reference type; this means that you will potentially be sharing the same list of Params between multiple calls to ExecuteDataSet. Instead, do something like this:
foreach (TParameter param in Params) {
cmd.Parameters.Add(new SqlParameter(param.ParameterName, param.SqlDbType, param.Size)).Value = param.Value;
}
Also, you could be potentially sharing the same SqlConnection between multiple threads, which could be a problem. Generally I would recommend creating a new SqlConnection within the ExecuteDataSet method. The new SqlConnection will still be able to enlist within any in-flight transaction.
Finally, use "using" blocks for all IDisposable objects, e.g., SqlCommand, SqlCommand, DataSet etc.

It sounds like the objects in this.ParamsList are being reused for every query. If you show how that list is defined and populated, we can confirm, but that's what it sounds like.
The solution is basically not to do that. Rebuild the parameter list with brand new SqlParameter objects for each query.
Otherwise you would have to employ some kind of locking to make sure two requests are not executed at the same time, but that seems like a worse solution.

C# overloaded constructors issue

I have the following class that I use to minimise code duplication when often calling different sets of data from an Oracle database. Primarily I need help to remove the code duplication in the overloaded constructor, but any other advice would be appreciated too.
public class UniformData
{
private string connection = "My Connection String";
private OracleConnection con;
private OracleCommand com;
private OracleDataReader reader;
public UniformData(string sql)
{
con = new OracleConnection(connection);
con.Open();
com = new OracleCommand(sql, con);
}
public UniformData(string sql, List<SqlParameters> myParams)
{
con = new OracleConnection(connection);
con.Open();
com = new OracleCommand(sql, con);
foreach (SqlParameters Param in myParams)
{
com.Parameters.Add(Param.ParamName, Param.ParamValue);
}
}
public OracleDataReader GetReader()
{
reader = com.ExecuteReader();
return reader;
}
~UniformData()
{
con.Close();
con.Dispose();
com.Dispose();
reader.Close();
reader.Dispose();
}
}

Normally I'd have a "canonical" constructor which all the other constructors chain to. In your case that would involve creating an empty list though:
public UniformData(string sql) : this(sql, new List<SqlParameters>())
{
}
public UniformData(string sql, List<SqlParameters> parameters)
{
con = new OracleConnection(connection);
con.Open();
com = new OracleCommand(sql, con);
foreach (SqlParameters parameter in parameters)
{
com.Parameters.Add(parameter.ParamName, parameter.ParamValue);
}
}
Alternatively, change the type of the parameter to IEnumerable<SqlParameters> at which point you can use Enumerable.Empty:
public UniformData(string sql) : this(sql, Enumerable.Empty<SqlParameters>())
{
}
public UniformData(string sql, IEnumerable<SqlParameters> parameters)
{
// Body as before
}
You can split the work the other way, as Mong Zhu's code does - but I tend to find it cleaner to keep all the work in a single place where possible. That makes it easy to validate that you've initialized all your variables properly in all cases - you only need to check that all constructors chain to the canonical one, and that the canonical one initializes everything.
Additionally I would:
Make your class implement IDisposable
Remove the finalizers

you can call the simpler constructor from the more complex one using this(parameter)
public UniformData(string sql)
{
con = new OracleConnection(connection);
con.Open();
com = new OracleCommand(sql, con);
}
public UniformData(string sql, List<SqlParameters> myParams): this(sql)
{
foreach (SqlParameters Param in myParams)
{
com.Parameters.Add(Param.ParamName, Param.ParamValue);
}
}
The original post is 7 years old, may be you missed it when researching.
The Using Constructors (C# Programming Guide) might yield further helpful information including my answer

Simply have one of the constructors call the other. Either have the overload without the parameters call the overload with the parameters, but passing an empty list, or have the overload with parameters call the overload without parameters to initialize the connection, so that it only needs to add the parameters.

How to unit test database methods in C#?

I've searched everywhere, but nothing I found was applicable to my current situation.
I have a class that helps with DB connections, and I need to unit test some of its methods:
public class DBHelper
{
private SqlConnection conn;
private SqlCommand textCommand;
public DBHelper(IDbConnection connection)
{
conn = (SqlConnection)connection;
textCommand = new SqlCommand();
textCommand.Connection = conn;
}
public SqlConnection Conn
{
get
{
return conn;
}
set
{
if (conn != null)
{
conn.Close();
conn.Dispose();
}
conn = (SqlConnection)value;
textCommand = new SqlCommand();
textCommand.Connection = conn;
textCommand.CommandType = CommandType.Text;
}
}
public object QueryScalar(string query)
{
textCommand.CommandText = query;
string qtype = query.Substring(0, 6).ToLower();
if (qtype == "select")
return textCommand.ExecuteScalar();
return textCommand.ExecuteNonQuery();
}
}
I know I shouldn't access the database from the test. I tried using mock objects but I don't think they can help here, because I cannot change textCommand from the outside of the class. I tried setting up an SQLite database and accessing it through SQL, but to no avail.
My question is: How can I unit test QueryScalar method?
Thank you for any ideas.

Perhaps you can use something like this in your class...
private IScalarQuerier _scalarQueryer;
public DBHelper(IDbConnection connection, IScalarQuerier q)
{
_scalarQuerier = q;
conn = (SqlConnection)connection;
textCommand = new SqlCommand();
textCommand.Connection = conn;
}
... and then place the QueryScalar method in a separate class, where you can do / test whatever you want. Just make that class implement an interface IScalarQuerier, so you can pass it in to DBHelper.
Might not be exactly what you were looking for, but this should let you do what you need with the method you want to test.
Sidenote: When you then pass that class (or IScalarQuerier-implementation, to be precise) into DBHelper, you should simply assume that the querier has been tested outside the scope of DBHelper, and that it therefore can be trusted to work correctly.

What's the most DRY-appropriate way to execute an SQL command?

I'm looking to figure out the best way to execute a database query using the least amount of boilerplate code. The method suggested in the SqlCommand documentation:
private static void ReadOrderData(string connectionString)
{
string queryString = "SELECT OrderID, CustomerID FROM dbo.Orders;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(queryString, connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
try
{
while (reader.Read())
{
Console.WriteLine(String.Format("{0}, {1}", reader[0], reader[1]));
}
}
finally
{
reader.Close();
}
}
}
mostly consists of code that would have to be repeated in every method that interacts with the database.
I'm already in the habit of factoring out the establishment of a connection, which would yield code more like the following. (I'm also modifying it so that it returns data, in order to make the example a bit less trivial.)
private SQLConnection CreateConnection()
{
var connection = new SqlConnection(_connectionString);
connection.Open();
return connection;
}
private List<int> ReadOrderData()
{
using(var connection = CreateConnection())
using(var command = connection.CreateCommand())
{
command.CommandText = "SELECT OrderID FROM dbo.Orders;";
using(var reader = command.ExecuteReader())
{
var results = new List<int>();
while(reader.Read()) results.Add(reader.GetInt32(0));
return results;
}
}
}
That's an improvement, but there's still enough boilerplate to nag at me. Can this be reduced further? In particular, I'd like to do something about the first two lines of the procedure. I don't feel like the method should be in charge of creating the SqlCommand. It's a tiny piece of repetition as it is in the example, but it seems to grow if transactions are being managed manually or timeouts are being altered or anything like that.
edit: Assume, at least hypothetically, there's going to have to be a bunch of different types of data being returned. And consequently the solution can't be just one one-size-fits-all method, there will have to be a few different ones depending, at minimum, on whether ExecuteNonQuery, ExecuteScalar, ExecuteReader, ExecuteReaderAsync, or any of the others are being called. I'd like to cut down on the repetition among those.

Tried Dapper?
Granted this doesn't get you a DataReader but you might just prefer it this way once you've tried it.
It's about the lightest-weight an ORM can be while still being called an ORM. No more methods to map between DataReader and strong types for me.
Used right here on all the StackExchange sites.
using (var conn = new SqlConnection(cs))
{
var dogs = connection.Query("select name, age from dogs");
foreach (dynamic dog in dogs)
{
Console.WriteLine("{0} age {1}", dog.name, dog.age);
}
}
or
using (var conn = new SqlConnection(cs))
{
var dogs = connection.Query<Dog>("select Name, Age from dogs");
foreach (Dog dog in dogs)
{
Console.WriteLine("{0} age {1}", dog.Name, dog.Age);
}
}
class Dog
{
public string Name { get; set; }
public int Age { get; set; }
}

If you want to roll data access on your own, this pattern of help methods could be one way to remove duplication:
private List<int> ReadOrderData()
{
return ExecuteList<int>("SELECT OrderID FROM dbo.Orders;",
x => x.GetInt32("orderId")).ToList();
}
private IEnumerable<T> ExecuteList(string query,
Func<IDataRecord, T> entityCreator)
{
using(var connection = CreateConnection())
using(var command = connection.CreateCommand())
{
command.CommandText = query;
connection.Open();
using(var reader = command.ExecuteReader())
{
while(reader.Read())
yield return entityCreator(reader);
}
}
}
You'll have to add support for parameters and this might not compile, but the pattern is what I'm trying to illustrate.

What I typically do is use a custom class that I wrote a while back that accepts a SQL string, and optionally a list of parameters and it returns a DataTable.
Since the thing that changes between invocations is typically just the SQL that is optimal IMHO.
If you truly do need to use a DataReader you can do something like this:
public void ExecuteWithDataReader(string sql, Action<DataReader> stuffToDo) {
using (SqlConnection connection = new SqlConnection(connectionString)) {
using (SqlCommand command = new SqlCommand(sql, connection)) {
connection.Open();
using (SqlDataReader reader = command.ExecuteReader()) {
try {
while (reader.Read()) {
stuffToDo(reader);
}
}
finally {
reader.Close();
}
}
}
}
}
private static void ReadOrderData(string connectionString) {
string sql = "SELECT OrderID, CustomerID FROM dbo.Orders;";
ExecuteWithDataReader(sql, r => Console.WriteLine(String.Format("{0}, {1}", r[0], r[1])));
}

The first two line are the most important thing you need...
but if you still wish to do it, you can turn them to a database handler class, yes it will become more of code, but in refactoring concept, every thing will move to the related topic...
try to write a singleton class, that receive a command and do action, so return result of type SqlDataReader reader...

Doing this in comments was too much.
I would suggest that the boilerplate code around
using(conn = new sqlconnection)
using(cmd = new sqlcommand) {
// blah blah blah
}
isn't something to be lightly removed and instead would encourage that you keep it exactly where it's at. Resources, especially unmanaged ones, should be opened and released at the closest point to execution as possible IMHO.
In no small part due to the ease with which other developers will fail to follow the appropriate clean up conventions.
If you do something like
private SQLConnection CreateConnection()
{
var connection = new SqlConnection(_connectionString);
connection.Open();
return connection;
}
Then you are inviting another programmer to call this method and completely fail to release the resource as soon as the query is executed. I don't know what kind of app you are building, but in a web app such a thing will lead to memory / connection / resource errors of types that are difficult to debug, unless you've been through it before.
Instead, I'd suggest you look into a lightweight ORM such as Dapper.net or similar to see how they approached it. I don't use dapper, but I hear it's pretty good. The reason I don't use it is simply that we don't allow inline sql to be executed against our databases (but that's a very different conversation).
Here's our standard:
public static DataTable StatisticsGet( Guid tenantId ) {
DataTable result = new DataTable();
result.Locale = CultureInfo.CurrentCulture;
Database db = DatabaseFactory.CreateDatabase(DatabaseType.Clients.ToString());
using (DbCommand dbCommand = db.GetStoredProcCommand("reg.StatsGet")) {
db.AddInParameter(dbCommand, "TenantId", DbType.Guid, tenantId);
result.Load(db.ExecuteReader(dbCommand));
} // using dbCommand
return result;
} // method::StatisticsGet
We make heavy use of Enterprise Library. It's short, simple and to the point and very well tested. This method just returns a datatable but you could easily have it return an object collection.. or nothing.

Which pattern is better for SqlConnection object?

Which pattern is better for SqlConnection object? Which is better in performance?
Do you offer any other pattern?
class DataAccess1 : IDisposable
{
private SqlConnection connection;
public DataAccess1(string connectionString)
{
connection = new SqlConnection(connectionString);
}
public void Execute(string query)
{
using (SqlCommand command = connection.CreateCommand())
{
command.CommandText = query;
command.CommandType = CommandType.Text;
// ...
command.Connection.Open();
command.ExecuteNonQuery();
command.Connection.Close();
}
}
public void Dispose()
{
connection.Dispose();
}
}
VS
class DataAccess2 : IDisposable
{
private string connectionString;
public DataAccess2(string connectionString)
{
this.connectionString = connectionString;
}
public void Execute(string query)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = connection.CreateCommand();
command.CommandText = query;
command.CommandType = CommandType.Text;
// ...
command.Connection.Open();
command.ExecuteNonQuery();
command.Connection.Close();
}
}
public void Dispose()
{
}
}

There's no real way to answer this question. The short, canonical answer is that the connection should stay alive for the lifetime of your unit of work. Because we have no way of knowing how DataAccess is used (does it exist for the lifetime of your application, or do you instantiate it and dispose it whenever you do something?), it's impossible to give a concrete answer.
That being said, I would recommend the first pattern, but instantiate and dispose of your DataAccess object as needed; don't keep it around longer than necessary.

Suggest going with DataAccess2. It's a personal preference though. Some might even suggest your class be static. It'd be difficult to say that one is more performant than the other. You're on the path of IDisposable, which is great.
I'd be happy to read and maintain both styles shown above in your question.
Consider having your DAL be able to read the connection string from a .config as well, rather than exclusively allowing the value to be passed in the constructor.
public DataAccess2(string connStr)
{
this.connectionString = connStr;
}
public DataAccess2()
{
this.connectionString =
ConfigurationManager.ConnectionStrings["foo"].ConnectionString;
}
Consider wrapping your SqlCommand in a using as well.
using (var conn = new SqlConnection(connectionString))
{
using(var cmd = conn.CreateCommand())
{
}
}

I think it depends on how your DataAccess object is intended to be used, if it's used within a 'using' clause then the connection is guaranteed to be disposed of after it's done.
But in general I prefer the second pattern as the sql connection is created and disposed of within the Execute method so it's less likely to be left open when you forget to dispose of your DataAccess object.
Considering that sql connection can be a scarse resource I think every attempt should be made to ensure that they're not wasted.

The first will result in errors if you make concurrent calls.
The second will ensure you use a clean connection for each command resulting in more connections being made.
I agree with the statements above that it depends on the scenario for use, to get over the problem related to the first I have a wrapper that needs to use such a pattern so I set a field value boolean to show that a command is being executed on the connection already then "queue" the next command for execution.
There will of course be situations where you may prefer to use multiple connections ...