Is de databaseverbinding in deze klasse herbruikbaar?

Het probleem waarmee je wordt geconfronteerd, is dat je jezelf hebt gecodeerd in een "nieuwe verbinding per actie"-hoek. Waar je echt naar wilt streven, en als best practice wordt beschouwd, is "nieuwe verbinding per batch van acties".

Wat ik in dit geval aanbeveel, is om de verbinding te openen wanneer dat nodig is en te sluiten wanneer deze wordt weggegooid. Wat we zullen doen, is de odbc-adapters naar een grotere scoped-variabele verplaatsen, zodat deze binnen de klasse toegankelijk is.

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

De volgende keer dat u uw klas gebruikt, doet u iets als

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

Aan het einde van dat codeblok, omdat het IDisposeable is, zal het die verbinding voor u sluiten in de verwijderingsmethode.

Dingen die ik heb veranderd:

• geïmplementeerd IDisposable interface
• methodes veranderd van statische naar klassemethodes.
• nieuwe methoden toegevoegd voor het openen van een sluitende verbinding
• verbindingsvariabele verplaatst naar bereik op klasseniveau
• een argument aan de constructor toegevoegd waarmee je een verbindingsreeks kunt invoeren (je moet deze verbindingsreeks in je Web.Config plaatsen

Bewerkingen:

• constructor neemt connectionString per suggestie in.