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

[rotteninside]

Ciao, ho un problema con questo errore "- 2147467259". OleDbException
Praticamente devo eseguire un'elaborazione massiva di dati, e dopo un certo numero (superiore alle 25 comunque) di connessioni aperte e chiuse, sulla Open successiva mi restituisce questo errore non specificato.
ho provato a verificare la versione di Mdac ma sono aggiornato all'ultima versione.
Qualcuno ha già verificato lo stesso errore e magari sa come risolverlo?
Tutto questo succede all'interno di un servizio.
Riavviato il servizio il database ritorna a funzionare fino a quando si pianta di nuovo e rimane bloccato.

Ciao, grazie

[riccardone]

dovresti postare il pezzo di codice che fa le operazioni sul db, come e quando apri e chiudi la connessione ecc.

[rotteninside]

E' un po' complicato, ti dovrei postare innumerevoli classi...

[riccardone]

allora non si puo' rispondere alla tua domanda. Es. apri una conn prima di ogni operazione e poi la richiudi subito dopo? Usi la stessa identica connectiostring per tutte le operazioni?

[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();
				}
			}
		}
		
	}
}

[riccardone]

Originariamente inviato da rotteninside
Nei metodi che ho implementato, apro e chiudo la connessione al Database in maniera corretta.

se fosse cosi, non dovresti avere problemi con le connessioni che rimangono aperte non credi?
Quindi, dovresti modificare la classe che usi perche' il problema e' li.
Non ho tempo di analizzare e testare la tua classe ma a prima vista, mi sembra che sarebbe piu' corretto evitare di mettere una istanza connection unica per tutte le funzioni. Meglio forse levare quell'oggetto evitando di istanziarlo ovviamente anche nel costruttore e creando una piu' semplice funzione es. GetConnection() che si legge (o riceve) la connection string e restituisce una nuova connection. A questo punto, e' il connection pool che si occupa di ottimizzare l'uso delle connessioni e l'unica cosa che devi stare attento e' chiudere sempre prima di uscire la connessione evitando di usare il datareader che invece e' un oggetto che tiene aperta la connessione (a nulla serve l'opzione close connection se poi chi usa il datareader non lo chiude per tanti motivi). Un altro errore che mi salta all'occhio e' il commandtimeout = 0. Perche' non lasci il valore di default?

[rotteninside]

e con le transazioni come faccio?
ho esigenza di fare diverse insert e aprendo e chiudendo tutte le volte non mi è possibile...

[riccardone]

la transazione e' legata alla connection. Una volta che hai la connection con associata una transazione assegni la stessa connection ai vari command. La tua classe helper in questo caso e' utile per avere facilmente una connection ed eventualmente un command (es. getcommand) ma poi l'esecuzione e il commit lo controlli in una classe intermedia che fa parte del cosidetto data access layer.
Una alternativa, puo' essere quella di applicare un design pattern che si chiama Unit Of Work. Questo pattern serve proprio per gestire le transazioni nel data access layer in maniera corretta. Non e' cosa che si risolve in una classe ma se ti interessa ecco qualche link
http://www.martinfowler.com/eaaCatalog/unitOfWork.html
una applicazione concreta
http://www.codeplex.com/NSK