[C#] Errore su Access con apertura di molte connessioni

[rotteninside]

Esatto, ho una classe DbManager che utilizzo ovunque mi serve il database.
Nei metodi che ho implementato, apro e chiudo la connessione al Database in maniera corretta.
Ti posto la classe:

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Data.Odbc;
using System.Data.OleDb; 
using log4net; 

namespace Utility
{
	/// <summary>
	/// Summary description for DBManager.
	/// </summary>
	public class DBManagerOle
	{

		private OleDbConnection objConn;
		private OleDbTransaction  objSqlTransaction;
		private Boolean bUseTransaction = false;
	
		//Definizione LOG4NET
		private static readonly ILog Log = LogManager.GetLogger(typeof(DBManagerOle));
		
		public DBManagerOle()
		{
		
		}
		public DBManagerOle(string connectionString)
		{
			
			objConn = new OleDbConnection();
			// TODO: Modify the connection string and include any
			// additional required properties for your database.
			objConn.ConnectionString = connectionString;

			Log.Info("Costruttore DbMAnager inizializzato correttamente. Istanza Connessione eseguita");
		}


		

		private void OpenConnection()
		{
			try
			{
				objConn.Open();
			}
			catch(OleDbException Err)
			{
				Log.Error(Err.Message,Err); 
				throw;
			}
			catch(Exception Err)
			{
				Log.Error(Err.Message,Err); 
				throw;
			}
		}

		//Start transazione
		public void BeginTransaction()
		{
			OpenConnection();
			bUseTransaction = true;
			objSqlTransaction = objConn.BeginTransaction();
		}

		//Commit Transazione
		public void CommitTransaction()
		{
			bUseTransaction = false;
			objSqlTransaction.Commit();
			CloseConnection();
		}


		//RollBack Transazione
		public void RollBackTransaction()
		{
			bUseTransaction = false;
			objSqlTransaction.Rollback();
			CloseConnection();
		}


		public string ConnectionState()
		{
			return objConn.State.ToString();
		}


		public OleDbDataReader GetDataReader(string SQL)
		{
			OleDbCommand objCommand= new OleDbCommand ();
			try
			{
				string sConnState = ConnectionState();
				if (sConnState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objCommand.Transaction =  objSqlTransaction;
				}
				objCommand.Connection = objConn;
				objCommand.CommandText = SQL;
				objCommand.CommandTimeout = 0;

				if (bUseTransaction == true)
				{
					return objCommand.ExecuteReader();
				}
				else
				{
					return objCommand.ExecuteReader(CommandBehavior.CloseConnection);
				}
			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
		}


		public OleDbDataReader GetDataReader(OleDbCommand comandoSQL)
		{
			OleDbCommand objCommand= comandoSQL;
			try
			{
				string sConnState = ConnectionState();
				if (sConnState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objCommand.Transaction = objSqlTransaction;
				}
				objCommand.Connection = objConn;
				//objCommand.CommandText = SQL;
				objCommand.CommandTimeout = 0;

				if (bUseTransaction == true)
				{
					return objCommand.ExecuteReader();
				}
				else
				{
					return objCommand.ExecuteReader(CommandBehavior.CloseConnection);
				}
			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
		}
				

		public DataSet GetDataSet	(OleDbCommand comandoSQL , string DataTable)
		{
			DataSet dstEorder = new DataSet();
			OleDbDataAdapter dadEorder; 
			OleDbCommand objCommand = comandoSQL;

			try
			{
				string sConnState = ConnectionState();
				if (sConnState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}

				//Transazione si/no
				if (bUseTransaction == true)
				{
					objCommand.Transaction = objSqlTransaction;
				}
				objCommand.Connection = objConn;
				objCommand.CommandTimeout = 0;
				
				dadEorder = new OleDbDataAdapter(objCommand);
				dadEorder.Fill(dstEorder, DataTable);

				return dstEorder;
			}
			catch ( Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw Err;                                  
			}
			finally
			{
				CloseConnection();
			}
		}





		private void CloseConnection()
		{
			objConn.Close();
			//objConn.Dispose();
		}

		public void updateDB(string SQL)
		{
			OleDbCommand objCommand= new OleDbCommand ();
			try
			{
				string sConnState = ConnectionState();
				if (sConnState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objCommand.Transaction = objSqlTransaction;
				}
				objCommand.Connection = objConn;
				objCommand.CommandText = SQL;
				objCommand.CommandTimeout = 0;
				objCommand.ExecuteNonQuery();
			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}



		public void updateDB(OleDbCommand comandoSQL)
		{
			OleDbCommand objCommand= comandoSQL;
			try
			{
				string sConnState = ConnectionState();
				if (sConnState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objCommand.Transaction = objSqlTransaction;
				}
				objCommand.Connection = objConn;
				//objCommand.CommandText = SQL;
				objCommand.CommandTimeout = 0;
				objCommand.ExecuteNonQuery();
			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}


		
		public int ExecuteScalar(string sql)
		{
			try
			{
				OleDbCommand objectCommand= new OleDbCommand();
				string connState = ConnectionState();
				
				if (connState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objectCommand.Transaction = objSqlTransaction;
				}
				objectCommand.Connection = objConn;
				objectCommand.CommandText = sql;
				objectCommand.CommandTimeout = 0;
				
				return (int) objectCommand.ExecuteScalar();


			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}
		

		public int ExecuteScalar(OleDbCommand comandoSQL)
		{
			try
			{
				OleDbCommand objectCommand= comandoSQL;
				string connState = ConnectionState();
				
				if (connState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objectCommand.Transaction = objSqlTransaction;
				}
				objectCommand.Connection = objConn;
				//objectCommand.CommandText = sql;
				objectCommand.CommandTimeout = 0;
				
				return  (int)objectCommand.ExecuteScalar();


			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				string query = this.ricostruisciQuery(comandoSQL);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}




		public int ExecuteNonQuery(string sql)
		{
			try
			{
				OleDbCommand objectCommand= new OleDbCommand();
				string connState = ConnectionState();
				
				if (connState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objectCommand.Transaction = objSqlTransaction;
				}
				objectCommand.Connection = objConn;
				objectCommand.CommandText = sql;
				objectCommand.CommandTimeout = 0;
				
				return (int) objectCommand.ExecuteNonQuery ();


			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}

		public int ExecuteNonQuery(OleDbCommand comandoSQL)
		{
			try
			{
				OleDbCommand objectCommand= comandoSQL;
				string connState = ConnectionState();
				
				if (connState.CompareTo("Open")!=0)
				{
					OpenConnection();
				}
				if (bUseTransaction == true)
				{
					objectCommand.Transaction = objSqlTransaction;
				}
				objectCommand.Connection = objConn;
				//objectCommand.CommandText = sql;
				objectCommand.CommandTimeout = 0;
				
				return (int) objectCommand.ExecuteNonQuery ();


			}
			catch (OleDbException Err)
			{
				Log.Error(Err.Message ,Err);
				string query = this.ricostruisciQuery(comandoSQL);
				throw;
			}
			catch (Exception Err)
			{
				Log.Error(Err.Message ,Err);
				string query = this.ricostruisciQuery(comandoSQL);
				Log.Error("Errore nella query : " + query);
				throw;
			}			
			finally
			{
				if (bUseTransaction == false)
				{
					CloseConnection();
				}
			}
		}
		
	}
}