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

Télécharger le projet
Commenter

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
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (romagny13)