La connexion à la base de données de cette classe est-elle réutilisable ?

Le problème que vous rencontrez est que vous vous êtes codé dans un coin "nouvelle connexion par action". Ce que vous voulez vraiment viser, et qui est considéré comme la meilleure pratique, c'est "une nouvelle connexion par lot d'actions".

Ce que je recommande dans ce cas, c'est d'ouvrir la connexion lorsque cela est nécessaire et de la fermer lorsqu'elle est éliminée. Ce que nous allons faire, c'est déplacer les adaptateurs odbc vers une variable de portée plus grande afin qu'elle soit accessible dans la classe.

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

Maintenant, la prochaine fois que vous utiliserez votre classe, faites quelque chose comme

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

À la fin de ce bloc de code, parce qu'il est IDisposeable, il fermera cette connexion pour vous dans la méthode dispose.

Choses que j'ai changé :

• implémenté IDisposable interfaces
• changement de méthodes de statiques en méthodes de classe.
• ajout de nouvelles méthodes pour ouvrir la connexion de fermeture
• variable de connexion déplacée vers la portée au niveau de la classe
• ajout d'un argument au constructeur qui vous permet de transmettre une chaîne de connexion (vous devez mettre cette chaîne de connexion dans votre Web.Config

Modifications :

• le constructeur prend connectionString par suggestion.