CodeS-SourceS est hébergé par Frontier.fr

Cliquez ici pour mettre ce site au démarrage de votre navigateur

AccueilCodesTutorielsForumsEmploiLivresGuide achatConnexion

begin process at 2009 07 05 02:42:40

SILVERLIGHT 3 : COMMUNICATION ET MULTICAST par KooKiz

[PERSO] DéCOUVERTES ESTIVALES : LINUX (PART I) par FREMYCOMPANY

[REFACTORING] RESHARPER POUR VISUAL STUDIO 2010 (PREVIEW) par tja

[REFACTORING] ANALYSER VOS EXCEPTIONS AVEC RESHARPER EXCEPTIONAL par tja

SHAREPOINT 2007 : PATTERNS & PRACTICES SHAREPOINT GUIDANCE par phil

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par spilz

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par casy

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par spilz

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par Robert33

MIGRATION BASE DE DONNéES par abouselma

+ de logiciels à télécharger

1 464 526 membres
33 nouveaux aujourd'hui
15 045 membres club

Trouver une ressource

Trouvez une ressource parmi 40 096 codes, 1 302 918 messages d'aide etc...

Recherche: dans [ Dernières recherches ]

Filtre:Tous les codes.NET uniquementExclure .NET

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

SYSTEM.DATA.COMMON.DBPROVIDERFACTORY - ACCES GÉNÉRIQUE AUX BASES DE DONNÉES

Information sur la source

Catégorie :Base de données

Classé sous : dbproviderfactory, ado, common Niveau : Initié Date de création : 04/01/2007 Date de mise à jour : 24/05/2007 09:13:34 Vu / téléchargé: 9 699 / 1 029

Auteur : romagny13

Site perso

Ecrire un message privé

Ce membre participe au partage de revenus publicitaires

Note :

9,00 / 10

Commentaire sur cette source (10)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

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

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

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

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Cs2DbProvider
- Cs2DbProvider.sln 1 436 octets
- Cs2DbProvider.suo29 184 octets
- Cs2DbProvider.Test
  - App.config 573 octets
  - Cs2DbProvider.Test.csproj 3 700 octets
  - Cs2DbProvider.Test.csproj.user 168 octets
  - Form1.cs 7 487 octets
  - Form1.Designer.cs 4 245 octets
  - Form1.resx 5 814 octets
  - Program.cs 490 octets
  - obj
    - Cs2DbProvider.Test.csproj.FileListAbsolute.txt 1 896 octets
    - Debug
      - Cs2DbProvider.Test.csproj.GenerateResource.Cache842 octets
      - Cs2DbProvider.Test.exe24 576 octets
      - Cs2DbProvider.Test.Form1.resources180 octets
      - Cs2DbProvider.Test.pdb30 208 octets
      - Cs2DbProvider.Test.Properties.Resources.resources180 octets
      - ResolveAssemblyReference.cache3 975 octets
      - TempPE
        
        bin.Debug.mapping.Designer.cs.dll15 360 octets
        
        ContactsDataSet.Designer.cs.dll45 056 octets
        
        DataSet1.Designer.cs.dll23 040 octets
        
        Properties.Resources.Designer.cs.dll5 120 octets
  - Properties
    - AssemblyInfo.cs 1 390 octets
    - Resources.Designer.cs 3 057 octets
    - Resources.resx 5 612 octets
    - Settings.Designer.cs 1 776 octets
    - Settings.settings1 023 octets
  - bin
    - Debug
      - ContactsDb.mdb364 544 octets
      - Cs2DbProvider.dll24 576 octets
      - Cs2DbProvider.pdb30 208 octets
      - Cs2DbProvider.Test.exe24 576 octets
      - Cs2DbProvider.Test.exe.config 573 octets
      - Cs2DbProvider.Test.pdb30 208 octets
      - Cs2DbProvider.Test.vshost.exe5 632 octets
      - Cs2DbProvider.Test.vshost.exe.config 573 octets
      - mapping.Designer.cs 171 404 octets
      - mapping.xml 1 037 octets
      - bin
        
        Debug
        
        ContactsDb.mdb364 544 octets
- Cs2DbProvider
  - ClassDiagram1.cd426 octets
  - Cs2DbProvider.csproj 2 098 octets
  - Cs2DbProvider.csproj.user 168 octets
  - DbProviderUtilities.cs 31 544 octets
  - obj
    - Cs2DbProvider.csproj.FileListAbsolute.txt 723 octets
    - Debug
      - Cs2DbProvider.dll24 576 octets
      - Cs2DbProvider.pdb30 208 octets
      - Refactor
        
        Cs2DbProvider.dll16 384 octets
  - Properties
    - AssemblyInfo.cs 1 540 octets
  - bin
    - Debug
      - Cs2DbProvider.dll24 576 octets
      - Cs2DbProvider.pdb30 208 octets

Télécharger le zip

Historique

13 mai 2007 01:06:49 :: .
13 mai 2007 01:09:33 :: .
13 mai 2007 11:54:16 :: .
13 mai 2007 21:24:42 :: .
13 mai 2007 21:30:36 :: .
13 mai 2007 21:32:19 :: . capture
23 mai 2007 21:44:04 :: . amélioration connexion,transaction,etc.
24 mai 2007 09:13:34 :: .

Sources du même auteur

REPOSITORY GENERATOR (FOR ENTERPRISE LIBRARY)

[ CS2GEN ] - GENERATEUR DE CODE NTIERS POUR BASES DE DONNÉE...

[.NET 3.0] OPENXML MANAGER - CHARGEMENT ET EDITION/SAUVEGAR...

[.NET 2.0] - CLASSE POUR GÉRER FACILEMENT LES PREDICATE POUR...

CS2GENLINQTOXML - XML + XPATH VISUALIZER + LINQ TO XML GENE...

Toutes les sources de romagny13

Sources de la même categorie

EXPORTER SCRIPT SQL SQL SERVER (CREATE - DROP - INSERT - TAB... par citt

BULKINSERT EN C# par Malkuth

SPLIT SQL SANS TABLE TEMPORAIRE par TheOnlyMaX

MOTEUR CSV ET RECORDSET PERSO par SwitchApocalyps

INSERER UN PHOTO DANS UNE BASE DE DONNÉES MYSQL/ORACLE par herold

Toutes les sources de la catégorie Base de données

Sources en rapport avec celle ci

GÉNÉRATEUR DE CODE - [ARCHITECTURE 2-TIERS - 3-TIERS - N-TI... par romagny13

LIAISON DE DONNÉES BASE ACCESS (.NET 2) par bestmomo

BIBLIOTHEQUE AVEC ADO.NET par khalid220v

QUELQUES EXEMPLES DE MISE EN OEUVRE D'ADO.NET par bestmomo

Commentaires et avis

Commentaire de mastervanou le 04/01/2007 21:31:14

merci!,merci!,merci!, je commencais a coder le même type de projet pour avoir toutes les classes d'acces aux données sous la main
comme ton travail est déjà plus abouti que le mien, je regarde ca et je rajouterai ce qui me manque

Commentaire de vladam le 06/01/2007 13:00:23 administrateur CS

Et bien, ce code n'a qu'un intérêt, c'est de montrer à la rigueur ce que vous pouvez faire avec les librairies de ADO.
Si je peux me permettre de donner un conseil aux débutants, pour partir du bon pied :
1) - si vous voulez coder vraiment votre DAL (data Access layer), utilisez Entreprise Library 2.0
2) - si vous voulez vraiment un code propre, utilisez un générateur de code, qui génèrera 100 % de votre DAL (modèle objet relationnel par exemple). MyGeneration est un très bon outil pour cela.

Mon avis (purement personnel), c'est qu'il est inutile d'utiliser dans un projet une classe comme celle-ci. En effet, pourquoi mettre une classe entre vous et ADO sachant qu'avec ADO, vous avez déjà tout sous la main.

En gros, je vous conseil très fortement de passer à la génération de code pour vos DAL, vous gagnerez un temps monstrueux, mais surtout 0 bug !

Amicalement,

Commentaire de romagny13 le 06/01/2007 23:27:57

de rien ! de rien ! de rien! MasterVanou

non mes classes se basent sur un principe simple c'est que seuls quelques parametres changent d'une requete a l'autre(le command.type et le commandText + les parametres), ainsi la connection est definie automatiquement(pas besoin de la coder), et pour definir les command il suffit de passer a une procedure le commandType et le commandText , puis on ajoute les parametres en appelant juste une methode
On a un minimum de code a saisir .. seulement à appeler les methodes des classes qui font tout et leur passer uniquement les parametres importants
on n'a pas des milliers de lignes de codes pour gerer chaque table ,mais une seule classe et finalement on ne saisi que les appels aux methodes, plus l'application est grosse et plus le gain est visible et enorme

Commentaire de romagny13 le 08/01/2007 23:41:26

Salut :)
Je suis ouvert à tout (du moment que c'est dit avec suffisament de gentillesse), mon but est d'essayer d'avoir les meilleures méthodes pour programmer, ce projet est plus un début et je suis d'accord que ce n'est pas "LA" solution" car en fait on n'a une partie persistance legere mais le code qui devrait etre gerer par la persistance est en fait deplacer seulement (meme s'il s'en trouve moins volumineux), d'un autre coté les generateurs de code du marché me conviennent assez peu, j'aime maitriser tout et ne pas etre dependant d'une solution tiers

Mais je veux bien recevoir les conseils des "vieux loups" de la programmation d'application de gestion,quelles methodes eux utilisent(programmation n-tiers ? en vue de decoupler les couches ? ou non )Utilisez vous le mode deconnecté ? jusqu'a quel point,... comment gerez vous les problemes generes par le mode deconnecte et l'acces concurrentiel et enfin finalement ne preconisez vous pas de developper une solution plus en contact direct avec les données(car apres tout c'est elles qui sont importantes) et en mode connecté ...

Donc si les pros veulent participer a ce sujet(debat ?) que lance ...
concernant les meilleures méthodes de développement pour les applications de gestion aujourd'hui ... allez y :)

Commentaire de t_barbillon le 11/01/2007 09:02:32

Salut, juste une petite question au passage, après avoir lu un peu (trop?) rapidement ta source : je me demandais pourquoi mettre un try catch juste pour relancer l'exception catchée? Si c'est pour informer les couches supérieures, tu peux ne pas catcher l'exception (en plus l'objet sera plus fortement typé), ou renvoyer un booléen et mettre à dispo une fonction du style GetLastError.
Pour ce qui est du débatt, je ne suis ni vieux loup ni pro des bdd, donc je m'abstiens ;)

Commentaire de romagny13 le 12/01/2007 02:21:25

Salut T_Barbillon :)

oui c'est vrai j'ai tendance un peu à abuser des try catch ...
c'est un peu la solution facile lorsqu'on n'a pas mis tous les tests en place ,pour se premunir contre tout plantage brut :p
sinon oui c'est vrai d'habitude j'utilise un booleen ou le nombre de lignes mis à jour

Oui je vois que tu es plutot un jeune chat lol mais si tu as des trucs interessants a dire vas y, ca ne pourra que faire avancer le "schmilblik", moi perso plus ca va et plus je me tourne vers le mode connecte, et j'essaie de bien separer les couches(presentation,metier,persistance + Binding entre Metier et presentation + O/R entre persistance et metier) sinon je vais me realiser (en fait je suis en plein dessus) un generateur de code complet pour la couche metier et la couche persistance qui reposera en parti sur les classes postées ici(et qui sera assez "legere") en fait
j'ai pour idée de faire un designer visuel(ressemblant un peu Power Amc cote designer) et qui permettra de generer a la fois le script de creation de la base (ACCES ou Sql Server), et le projet Visual studio(couche Metier + persistance) si vous etes sage lol peut etre que je posterai les sources sur codes-sources :p
++

Commentaire de Bidou le 12/01/2007 14:01:00 administrateur CS

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...)

Commentaire de romagny13 le 14/05/2007 23:02:01

Bon si vous voulez mettre un petit 10 la vous génez pas :p lol ca fait toujours plaisir quand même

Commentaire de sistemaster le 18/12/2007 19:44:20

Thanks you !!!!

From Chili

Commentaire de inoussyago le 17/06/2009 14:00:33

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.

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

dataset et ADO.net c# [ par calaps ] (re)Bonjour,Suite à mon message de hier, j'ai denouveau une question ...En fait, j'ai un dataset qui contient un certain nombres de données en mémoire Ado.net command + parameter [ par SebSharp ] Bonjour a tous, Il est possible en sql de faire "Select * From Categories where CategorieId in ( 1, 2 )". J'aimerais savoir s'il est possible de faire ado.net vs sql server [ par Fildomen ] salutje peux savoir les avantages et les inconvénients de ces deux trucs de base de données??? y compri la vitesse d'execution des requestes :-)mercih comment executer les commandes parametrées en ado.net [ par Fildomen ] salutsvp montrer moi comment executer les commandes parametrées en ado.net?mercihttp://www.devportail.tk ADO / Excel [ par Bidou ] Bonjour,Dans le cadre d'une windowsApplication, je souhaite permettre une exportation (d'une collection) au format xls (excel). Je n'ai trouvé aucun c DAO et ADO.NET [ par RL ] J'ai l'habitude de DAO mais pas d' ADO.NETPeut-on éffacer et créer des tables dans une base de données Access avec ADO.NET?( Equivalent de TableDefs.D Ado.net , dataset et structure [ par thiosyiasar ] Bien le boujour à tous.Depuis les journées rencontres aux données de Microsoft, je me suis penché sur ado.net.Le dataset permet de Xml au format ADO et Datagrid [ par scoadou ] SalutJ'ai un fichier XML au format ADO (Schema + Données). J'aimerais le "binder" à un datagrid dans une Webform. J'ai lu que les formats de Ado.Net & datashaping [ par t_barbillon ] Salut, je voulais savoir si c'était possible de faire du datashaping sous ADO.Net Je m'explique : avant j'utilisais la DLL d'interop ADODB.DLL et Connection ADO sécurisée [ par MAQFAB ] Messieurs dames, bien le bonjour.Je suis en train de développer une appli sous C#, avec une BDD SQL Server. Ma base se trouve chez mon héber