System.data.common.dbproviderfactory - acces générique aux bases de données

Soyez le premier à donner votre avis sur cette source.

Vue 16 260 fois - Téléchargée 1 464 fois

Description

Donc je propose ici une classe permettant un accès générique aux données grace à System.Data.common,
ainsi on peut aussi bien se connecter à une base de données SQL Server que Access,etc.
Il suffit de renseigner la propriété ProviderName du DbProviderFactory.

- la classe prend en charge les chaines de connexions définies dans les fichiers de configuration
- les méthodes ont plusieurs signatures quand même (on peut ainsi charger un DataSet ou une DataTable, ou utiliser un DataReader pour la consultation, sans oublier ExecuteScalar / pour la mise à jour on peut utiliser soit ExecuteNonQuery soit mettre à jour un DataSet ou une DataTable grace à un DbDataAdapter / elle offre aussi une facilité pour les transactions et le mapping)

bon cette classe ne présente en fait rien de plus que ce que l'on peut déja trouver comme Entreprise Library (même plutot moins lol)
De plus ce que je reproche à ce genre de solution c'est que l'on a encore beaucoup trop à coder

la source inclut un petit projet de test avec un fichier de configuration pour ceux qui ne connaissent pas

+

Source / Exemple :


using System;
using System.Collections.Generic;
using System.Text;

namespace Cs2DbProvider
{
    /// <summary>
    /// Cette classe permet un accès générique aux données quel que soit le provider utilisé .
    /// </summary>
    public class DbProviderUtilities
    {

        private System.Configuration.ConnectionStringsSection _ConnectionStringsSection;

        private System.Data.Common.DbProviderFactory _DbProviderFactory;

        public System.Data.Common.DbProviderFactory DbProviderFactory
        {
            get { return _DbProviderFactory; }
        }

        public System.Configuration.ConnectionStringsSection ConnectionStringsSection
        {
            get { return _ConnectionStringsSection; }
            set { _ConnectionStringsSection = value; }
        }

        public DbProviderUtilities()
        { }

        /// <summary>
        /// récupère les connections définies dans le fichier de configuration
        /// </summary>
        /// <returns></returns>
        public bool GetConfigurationConnections()
        {
            bool bResult = false;
            try
            {
                System.Configuration.Configuration oConfiguration = System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None);
                if (oConfiguration.HasFile)
                {
                    this._ConnectionStringsSection = oConfiguration.ConnectionStrings;
                    bResult = true;
                }
                else
                { }
            }
            catch (System.Configuration.ConfigurationErrorsException ex)
            {
                throw ex;
            }

            return bResult;

        }
       
        /// <summary>
        /// crée la connection
        /// </summary>
        /// <returns></returns>
        public System.Data.Common.DbConnection CreateConnection()
        {
            _DbProviderFactory = System.Data.Common.DbProviderFactories.GetFactory(_ConnectionStringsSection.ConnectionStrings[1].ProviderName);
            System.Data.Common.DbConnection oDbConnnection = _DbProviderFactory.CreateConnection();
            oDbConnnection.ConnectionString = _ConnectionStringsSection.ConnectionStrings[1].ConnectionString;

            return oDbConnnection;
        }
        /// <summary>
        /// crée la connection 
        /// </summary>
        /// <param name="nConfigurationConnectionIndex"></param>
        /// <returns></returns>
        public System.Data.Common.DbConnection CreateConnection(int nConfigurationConnectionIndex)
        {
            _DbProviderFactory = System.Data.Common.DbProviderFactories.GetFactory(_ConnectionStringsSection.ConnectionStrings[nConfigurationConnectionIndex].ProviderName);
            System.Data.Common.DbConnection oDbConnnection = _DbProviderFactory.CreateConnection();
            oDbConnnection.ConnectionString = _ConnectionStringsSection.ConnectionStrings[nConfigurationConnectionIndex].ConnectionString;

            return oDbConnnection;
        }
        /// <summary>
        /// crée la connection
        /// </summary>
        /// <param name="sConfigurationConnectionName"></param>
        /// <returns></returns>
        public System.Data.Common.DbConnection CreateConnection(string sConfigurationConnectionName)
        {
            _DbProviderFactory = System.Data.Common.DbProviderFactories.GetFactory(_ConnectionStringsSection.ConnectionStrings[sConfigurationConnectionName].ProviderName);
            System.Data.Common.DbConnection oDbConnnection = _DbProviderFactory.CreateConnection();
            oDbConnnection.ConnectionString = _ConnectionStringsSection.ConnectionStrings[sConfigurationConnectionName].ConnectionString;

            return oDbConnnection;
        }
        /// <summary>
        /// Crée la connection
        /// </summary>
        /// <param name="ProviderName"></param>
        /// <param name="ConnectionString"></param>
        /// <returns></returns>
        public System.Data.Common.DbConnection CreateConnection(string ProviderName, string ConnectionString)
        {
            _DbProviderFactory = System.Data.Common.DbProviderFactories.GetFactory(ProviderName);
            System.Data.Common.DbConnection oDbConnnection = _DbProviderFactory.CreateConnection();
            oDbConnnection.ConnectionString = ConnectionString;

            return oDbConnnection;
        }
        /// <summary>
        /// Crée une commande
        /// </summary>
        /// <param name="CommandText"></param>
        /// <param name="oDbConnection"></param>
        /// <param name="CommandType"></param>
        /// <returns></returns>
        public System.Data.Common.DbCommand CreateCommand(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType)
        {
            System.Data.Common.DbCommand oDbCommand = DbProviderFactory.CreateCommand();
            oDbCommand.CommandType = CommandType;
            oDbCommand.CommandText = CommandText;
            oDbCommand.Connection = oDbConnection;

            return oDbCommand;
        }
        public System.Data.Common.DbCommand CreateCommand(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType,System.Data.Common.DbTransaction Transaction)
        {
            System.Data.Common.DbCommand oDbCommand = DbProviderFactory.CreateCommand();
            oDbCommand.CommandType = CommandType;
            oDbCommand.CommandText = CommandText;
            oDbCommand.Connection = oDbConnection;
            oDbCommand.Transaction = Transaction;

            return oDbCommand;
        }
        /// <summary>
        /// crée un paramètre
        /// </summary>
        /// <param name="ParameterName"></param>
        /// <param name="DbType"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public System.Data.Common.DbParameter CreateParameter(string ParameterName, System.Data.DbType DbType, object Value)
        {
            System.Data.Common.DbParameter oDbParameter = DbProviderFactory.CreateParameter();
            oDbParameter.ParameterName = ParameterName;
            oDbParameter.DbType = DbType;
            oDbParameter.Value = Value;

            return oDbParameter;
        }
        /// <summary>
        /// crée un paramètre
        /// </summary>
        /// <param name="ParameterName"></param>
        /// <param name="DbType"></param>
        /// <param name="ParameterDirection"></param>
        /// <param name="SourceColumn"></param>
        /// <param name="DataRowVersion"></param>
        /// <param name="SourceColumnNullMapping"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public System.Data.Common.DbParameter CreateParameter(string ParameterName, System.Data.DbType DbType, System.Data.ParameterDirection ParameterDirection, string SourceColumn, System.Data.DataRowVersion DataRowVersion, bool SourceColumnNullMapping, object Value)
        {
            System.Data.Common.DbParameter oDbParameter = DbProviderFactory.CreateParameter();
            oDbParameter.ParameterName = ParameterName;
            oDbParameter.DbType = DbType;
            oDbParameter.Direction = ParameterDirection;
            oDbParameter.SourceColumn = SourceColumn;
            oDbParameter.SourceVersion = DataRowVersion;
            oDbParameter.SourceColumnNullMapping = SourceColumnNullMapping;
            oDbParameter.Value = Value;

            return oDbParameter;
        }
        /// <summary>
        /// crée un paramètre
        /// </summary>
        /// <param name="ParameterName"></param>
        /// <param name="DbType"></param>
        /// <param name="ParameterDirection"></param>
        /// <param name="SourceColumn"></param>
        /// <param name="DataRowVersion"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public System.Data.Common.DbParameter CreateParameter(string ParameterName, System.Data.DbType DbType, System.Data.ParameterDirection ParameterDirection, string SourceColumn, System.Data.DataRowVersion DataRowVersion, object Value)
        {
            System.Data.Common.DbParameter oDbParameter = DbProviderFactory.CreateParameter();
            oDbParameter.ParameterName = ParameterName;
            oDbParameter.DbType = DbType;
            oDbParameter.Direction = ParameterDirection;
            oDbParameter.SourceColumn = SourceColumn;
            oDbParameter.SourceVersion = DataRowVersion;
            oDbParameter.Value = Value;

            return oDbParameter;
        }
        /// <summary>
        /// crée le mapping d'une table
        /// </summary>
        /// <param name="SourceTable"></param>
        /// <param name="DataSetTable"></param>
        /// <param name="oColumnMappingCollection"></param>
        /// <returns></returns>
        public System.Data.Common.DataTableMapping CreateDataTableMapping(string SourceTable, string DataSetTable, System.Data.Common.DataColumnMappingCollection oDataColumnMappings)
        {
            System.Data.Common.DataTableMapping oDataTableMapping = new System.Data.Common.DataTableMapping(SourceTable, DataSetTable);
            foreach (System.Data.Common.DataColumnMapping oDataColumnMapping in oDataColumnMappings)
            {
                oDataTableMapping.ColumnMappings.Add(oDataColumnMapping);
            }
            return oDataTableMapping;
        }

        /// <summary>
        /// crée le mapping d'une colonne
        /// </summary>
        /// <param name="SourceColumn"></param>
        /// <param name="DataSetColumn"></param>
        /// <returns></returns>
        public System.Data.Common.DataColumnMapping CreateDataColumnMapping(string SourceColumn, string DataSetColumn)
        {
            System.Data.Common.DataColumnMapping oDataColumnMapping = new System.Data.Common.DataColumnMapping(SourceColumn, DataSetColumn);
            return oDataColumnMapping;
        }
        /// <summary>
        /// éxécute une requête de mise à jour (insert,update,delete,...)
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(System.Data.Common.DbCommand oDbCommand)
        {
            int nResult = 0;
            try
            {
                oDbCommand.Connection.Open();
                nResult = oDbCommand.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbCommand.Connection.Close();
            }
            return nResult;
        }
        /// <summary>
        /// éxecute une requête select ne retournant qu'un résultat
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public object ExecuteScalar(System.Data.Common.DbCommand oDbCommand)
        {
            object oResult = null;
            try
            {
                oDbCommand.Connection.Open();
                oResult = oDbCommand.ExecuteScalar();

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbCommand.Connection.Close();
            }
            return oResult;
        }
        /// <summary>
        /// éxecute un reader
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public System.Data.Common.DbDataReader ExecuteReader(System.Data.Common.DbCommand oDbCommand)
        {
            System.Data.Common.DbDataReader oDbDataReader;
            try
            {
                oDbCommand.Connection.Open();
                oDbDataReader = oDbCommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbCommand.Connection.Close();
            }
            return oDbDataReader;
        }
        /// <summary>
        /// rempli un DataSet
        /// </summary>
        /// <param name="CommandText"></param>
        /// <param name="oDbConnection"></param>
        /// <param name="CommandType"></param>
        /// <returns></returns>
        public System.Data.DataSet FillDataSet(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataSet oDataSet = new System.Data.DataSet();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand.Connection = oDbConnection;
                oDbDataAdapter.SelectCommand.CommandType = CommandType;
                oDbDataAdapter.SelectCommand.CommandText = CommandText;

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataSet;
        }
        /// <summary>
        /// rempli un DataSet
        /// </summary>
        /// <param name="CommandText"></param>
        /// <param name="oDbConnection"></param>
        /// <param name="CommandType"></param>
        /// <param name="oDataTableMapping"></param>
        /// <returns></returns>
        public System.Data.DataSet FillDataSet(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataSet oDataSet = new System.Data.DataSet();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand.Connection = oDbConnection;
                oDbDataAdapter.SelectCommand.CommandType = CommandType;
                oDbDataAdapter.SelectCommand.CommandText = CommandText;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataSet;
        }
        /// <summary>
        /// rempli un DataSet
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public System.Data.DataSet FillDataSet(System.Data.Common.DbCommand oDbCommand)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataSet oDataSet = new System.Data.DataSet();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = oDbCommand;

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataSet;
        }
        /// <summary>
        /// rempli un DataSet
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public System.Data.DataSet FillDataSet(System.Data.Common.DbCommand oDbCommand, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataSet oDataSet = new System.Data.DataSet();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = oDbCommand;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataSet;
        }
        /// <summary>
        /// rempli une DataTable
        /// </summary>
        /// <param name="CommandText"></param>
        /// <param name="oDbConnection"></param>
        /// <param name="CommandType"></param>
        /// <returns></returns>
        public System.Data.DataTable FillDataTable(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataTable oDataTable = new System.Data.DataTable();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand.Connection = oDbConnection;
                oDbDataAdapter.SelectCommand.CommandType = CommandType;
                oDbDataAdapter.SelectCommand.CommandText = CommandText;

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataTable;
        }
        /// <summary>
        /// rempli une DataTable
        /// </summary>
        /// <param name="CommandText"></param>
        /// <param name="oDbConnection"></param>
        /// <param name="CommandType"></param>
        /// <param name="oDataTableMapping"></param>
        /// <returns></returns>
        public System.Data.DataTable FillDataTable(String CommandText, System.Data.Common.DbConnection oDbConnection, System.Data.CommandType CommandType, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataTable oDataTable = new System.Data.DataTable();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand.Connection = oDbConnection;
                oDbDataAdapter.SelectCommand.CommandType = CommandType;
                oDbDataAdapter.SelectCommand.CommandText = CommandText;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataTable;
        }
        /// <summary>
        /// rempli une DataTable
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <returns></returns>
        public System.Data.DataTable FillDataTable(System.Data.Common.DbCommand oDbCommand)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataTable oDataTable = new System.Data.DataTable();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = oDbCommand;

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataTable;
        }
        /// <summary>
        /// rempli une DataTable
        /// </summary>
        /// <param name="oDbCommand"></param>
        /// <param name="oDataTableMapping"></param>
        /// <returns></returns>
        public System.Data.DataTable FillDataTable(System.Data.Common.DbCommand oDbCommand, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;
            System.Data.DataTable oDataTable = new System.Data.DataTable();

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = oDbCommand;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.SelectCommand.Connection.Open();
                oDbDataAdapter.Fill(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                oDbDataAdapter.SelectCommand.Connection.Close();
            }
            return oDataTable;
        }
        /// <summary>
        /// met à jour un DataSet
        /// </summary>
        /// <param name="SelectCommand"></param>
        /// <param name="InsertCommand"></param>
        /// <param name="UpdateCommand"></param>
        /// <param name="DeleteCommand"></param>
        /// <param name="ContinueUpdateOnError"></param>
        /// <returns></returns>
        public int UpdateDataSet(System.Data.Common.DbCommand SelectCommand, System.Data.Common.DbCommand InsertCommand, System.Data.Common.DbCommand UpdateCommand, System.Data.Common.DbCommand DeleteCommand, System.Data.DataSet oDataSet, bool ContinueUpdateOnError)
        {
            int nLignes = 0;
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = SelectCommand;
                oDbDataAdapter.InsertCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.InsertCommand = InsertCommand;
                oDbDataAdapter.UpdateCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.UpdateCommand = UpdateCommand;
                oDbDataAdapter.DeleteCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.DeleteCommand = DeleteCommand;

                oDbDataAdapter.ContinueUpdateOnError = ContinueUpdateOnError;

                nLignes = oDbDataAdapter.Update(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return nLignes;
        }
        /// <summary>
        /// met à jour un DataSet
        /// </summary>
        /// <param name="SelectCommand"></param>
        /// <param name="InsertCommand"></param>
        /// <param name="UpdateCommand"></param>
        /// <param name="DeleteCommand"></param>
        /// <param name="oDataSet"></param>
        /// <param name="ContinueUpdateOnError"></param>
        /// <param name="oDataTableMapping"></param>
        /// <returns></returns>
        public int UpdateDataSet(System.Data.Common.DbCommand SelectCommand, System.Data.Common.DbCommand InsertCommand, System.Data.Common.DbCommand UpdateCommand, System.Data.Common.DbCommand DeleteCommand, System.Data.DataSet oDataSet, bool ContinueUpdateOnError, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            int nLignes = 0;
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = SelectCommand;
                oDbDataAdapter.InsertCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.InsertCommand = InsertCommand;
                oDbDataAdapter.UpdateCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.UpdateCommand = UpdateCommand;
                oDbDataAdapter.DeleteCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.DeleteCommand = DeleteCommand;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.ContinueUpdateOnError = ContinueUpdateOnError;

                nLignes = oDbDataAdapter.Update(oDataSet);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return nLignes;
        }
        /// <summary>
        /// met à jour une DataTable
        /// </summary>
        /// <param name="SelectCommand"></param>
        /// <param name="InsertCommand"></param>
        /// <param name="UpdateCommand"></param>
        /// <param name="DeleteCommand"></param>
        /// <param name="ContinueUpdateOnError"></param>
        /// <returns></returns>
        public int UpdateDataTable(System.Data.Common.DbCommand SelectCommand, System.Data.Common.DbCommand InsertCommand, System.Data.Common.DbCommand UpdateCommand, System.Data.Common.DbCommand DeleteCommand, System.Data.DataTable oDataTable, bool ContinueUpdateOnError)
        {
            int nLignes = 0;
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = SelectCommand;
                oDbDataAdapter.InsertCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.InsertCommand = InsertCommand;
                oDbDataAdapter.UpdateCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.UpdateCommand = UpdateCommand;
                oDbDataAdapter.DeleteCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.DeleteCommand = DeleteCommand;

                oDbDataAdapter.ContinueUpdateOnError = ContinueUpdateOnError;

                nLignes = oDbDataAdapter.Update(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return nLignes;
        }
        /// <summary>
        /// met à jour une DataTable
        /// </summary>
        /// <param name="SelectCommand"></param>
        /// <param name="InsertCommand"></param>
        /// <param name="UpdateCommand"></param>
        /// <param name="DeleteCommand"></param>
        /// <param name="oDataTable"></param>
        /// <param name="ContinueUpdateOnError"></param>
        /// <param name="oDataTableMapping"></param>
        /// <returns></returns>
        public int UpdateDataTable(System.Data.Common.DbCommand SelectCommand, System.Data.Common.DbCommand InsertCommand, System.Data.Common.DbCommand UpdateCommand, System.Data.Common.DbCommand DeleteCommand, System.Data.DataTable oDataTable, bool ContinueUpdateOnError, System.Data.Common.DataTableMapping oDataTableMapping)
        {
            int nLignes = 0;
            System.Data.Common.DbDataAdapter oDbDataAdapter = null;

            try
            {
                oDbDataAdapter = _DbProviderFactory.CreateDataAdapter();
                oDbDataAdapter.SelectCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.SelectCommand = SelectCommand;
                oDbDataAdapter.InsertCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.InsertCommand = InsertCommand;
                oDbDataAdapter.UpdateCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.UpdateCommand = UpdateCommand;
                oDbDataAdapter.DeleteCommand = DbProviderFactory.CreateCommand();
                oDbDataAdapter.DeleteCommand = DeleteCommand;
                oDbDataAdapter.TableMappings.Add(oDataTableMapping);

                oDbDataAdapter.ContinueUpdateOnError = ContinueUpdateOnError;

                nLignes = oDbDataAdapter.Update(oDataTable);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return nLignes;
        }
        /// <summary>
        /// commence une transaction
        /// </summary>
        /// <param name="oDbConnection"></param>
        /// <returns></returns>
        public System.Data.Common.DbTransaction BeginTransaction(System.Data.Common.DbConnection oDbConnection)
        {
            try
            {
                System.Data.Common.DbTransaction oDbTransaction = oDbConnection.BeginTransaction();
                return oDbTransaction;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// valide la transaction
        /// </summary>
        /// <param name="oDbTransaction"></param>
        public void CommitTransaction(System.Data.Common.DbTransaction oDbTransaction)
        {
            try
            {
                oDbTransaction.Commit();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// annule la transaction
        /// </summary>
        /// <param name="oDbTransaction"></param>
        public void RollbackTransaction(System.Data.Common.DbTransaction oDbTransaction)
        {
            try
            {
                oDbTransaction.Rollback();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}

Conclusion :


Note : si vous copiez coller la classe n'oubliez pas d'ajouter une référence à System.configuration.dll

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
24
Date d'inscription
samedi 4 mars 2006
Statut
Membre
Dernière intervention
7 mai 2009

Salut,

Merci pour ta source, elle m'est très utile....
J'ai quand même une petite question. Avec une base SQL CE, comment fais-tu pour récupérer le dernier identity ajouté à la base? Avec SQL CE, on ne peut pas envoyer plus d'une requête à la fois...
"INSERT INTO "nom de table" ("colonne 1", "colonne 2", ...) VALUES ("valeur 1", "valeur 2", ...); SELECT @@IDENTITY" n'est donc pas possible...

Gwendal
Messages postés
9
Date d'inscription
jeudi 14 décembre 2000
Statut
Membre
Dernière intervention
11 juillet 2009

Salut je suis peut etre un debutant dans tout ce qui es .NET, mais je te felicite.

Je sais pas trop quelle l'objectif que tu as en ayant creer cette classe, mais je t'encourage quand même.
Je pense que cela montre que tu as une assez bonne maitrise de ces outils de persistance qu'ado nous offre.
Certe pour des projet consequents (important) l'ideal serait d'utiliser les librairie ADO.
Mais comme etudiant ce genre de projet nous forme.
Messages postés
1
Date d'inscription
mardi 9 janvier 2007
Statut
Membre
Dernière intervention
18 décembre 2007

Thanks you !!!!

From Chili
Messages postés
687
Date d'inscription
lundi 10 janvier 2005
Statut
Membre
Dernière intervention
27 août 2014
2
Bon si vous voulez mettre un petit 10 la vous génez pas :p lol ca fait toujours plaisir quand même
Messages postés
5487
Date d'inscription
dimanche 4 août 2002
Statut
Modérateur
Dernière intervention
20 juin 2013
49
Je ne suis pas un spécialiste des DB (loin de là), mais je dois avouer que je rejoins un peu vladam. Dans 95% des cas, on peut faire tout ce qu'on veut avec ce qui nous est donné dans le framework, et ceci en relativement peu de ligne. Du coup, de tel projet ne sont pas vraiment utile (même si j'avoue que j'ai pas tout regarder ton code, mais ça à l'air conséquent, pour finalement pas grand chose...)
Afficher les 11 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.