Ist die Datenbankverbindung in dieser Klasse wiederverwendbar?

Das Problem, dem Sie gegenüberstehen, ist, dass Sie sich selbst in eine „Neue Verbindung pro Aktion“-Ecke codiert haben. Was Sie wirklich anstreben möchten und als bewährte Methode gelten, ist „neue Verbindung pro Stapel von Aktionen“.

Was ich in diesem Fall empfehle, ist, die Verbindung bei Bedarf zu öffnen und bei der Entsorgung zu schließen. Was wir tun werden, ist, die odbc-Adapter in eine Variable mit größerem Geltungsbereich zu verschieben, damit innerhalb der Klasse darauf zugegriffen werden kann.

namespace databaseFunctions
{
    public class databaseConnection:IDisposable
    {
        private OdbcConnection con;
        private string connectionString;

        public databaseConnection(string connectionString){
            this.connectionString = connectionString;
        }


        public void OpenConnection(){
            if (con == null || con.IsClosed ){ // we make sure we're only opening connection once.
                con = new OdbcConnection(this.connectionString);
            }
        }
        public void CloseConnection(){
            if (con != null && con.IsOpen){ // I'm making stuff up here
                con.Close();
            }
        }

        public DataTable getFromDatabase(string SQL)
        {
            OpenConnection();

            DataTable rt = new DataTable();
            DataSet ds = new DataSet();
            OdbcCommand cmd = new OdbcCommand(SQL, con);
            da.SelectCommand = cmd;
            da.Fill(ds);
            try
            {
                rt = ds.Tables[0];
            }
            catch
            {   
                rt = null;
            }
            return rt;
        }

        public Boolean insertIntoDatabase(string SQL)
        {
            OpenConnection();

            OdbcCommand cmd = new OdbcCommand(SQL, con);
            con.Open();
            try
            {
                cmd.ExecuteNonQuery();
                return true;
            }
            catch
            {
                return false;
            }

        }


        // Implementing IDisposable method
        public void Dispose(){
            CloseConenction();
        }
    }
}

Wenn Sie jetzt Ihre Klasse das nächste Mal verwenden, tun Sie so etwas wie

using (DatabaseConnection db = new DatabaseConnection()){
    db.InsertIntoDatabase(...);
    db.GetLastInsertID();
    db.GetFromDatabase(...);
}

Am Ende dieses Codeblocks wird diese Verbindung für Sie in der Dispose-Methode geschlossen, da er IDisposeable ist.

Dinge, die ich geändert habe:

• implementierte IDisposable Schnittstelle
• Methoden von statischen zu Klassenmethoden geändert.
• neue Methoden zum Öffnen und Schließen von Verbindungen hinzugefügt
• Verbindungsvariable in den Geltungsbereich der Klassenebene verschoben
• dem Konstruktor ein Argument hinzugefügt, mit dem Sie eine Verbindungszeichenfolge übergeben können (Sie sollten diese Verbindungszeichenfolge in Ihre Web.Config einfügen

Änderungen:

• Konstruktor übernimmt connectionString pro Vorschlag.