Discussion :

[ben_skywalker]

Bonjour,

J'ai une question concernant un projet que je souhaiterais voir aboutir.
Comment rendre un projet (ASP.net / C#) "compatible" avec plusieurs type de base de données?
[Rétorique] avec une interface si je ne m'abuse.

Vous allez me demander l'utilité d'un tel projet?
Tous simplement faire en sorte que mon projet puisse fonctionner sur des configurations différentes dans l'état où elles sont sans modifications du code, et sans nouvelle installation. un réseau avec une base de données MSSQL, ou un réseau avec une base de données MySQL, ou encore une BDD Oracle.

Et des bases de donnée embarquer type Mysqli ou lite (je sais plus mais vous m’aurez compris) ?
Je ne souhaite pas les utiliser vue qu'a terme la quantité de donnée sera considérable autant sur un serveur de test ça pourrais bien rendre autant en prod je vois mal ces système géré des millions d'enregistrements.

J'ai créé une page de configuration pour entrer les paramètres des bases (cela fonctionne)

Maintenant passons au cœur de mon problème j'ai essayé de faire une interface et de m'en servir pour me connecter aux base de donnée sauf que les type étant ce qu'il sont, MySQLConnetion est différent de SQLConnection et je suppose (j'ai pas encore travailler sur de l'Oracle) de OracleConnection...

Donc voilà ma question :
Comment faire un connecteur unique pour différents type de base de données?

J'espère que je ne vous aurais pas perdu en cours de route
et merci d'avance

PS : j'ai fait une petite recherche avant, mais je n'es rien trouver de véritablement pertinent si vous êtes plus chanceux n'ésitez pas à me donner un lien avec la solution à mon problème

[bossun]

Salut,

Voilà ton bonheur,

J'ai fait ce travail y a quelques années

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Configuration;
    using System.Data.Common;
    using System.Data;
    namespace CrmDbClient
    {
    public class CrmDbClientException:Exception
    {
    public CrmDbClientException(string Message):base(Message){}
    public CrmDbClientException(string Message, Exception inerException) : base(Message, inerException) { }
    }
    public class CrmDbClient : IDisposable
    {
    private IDbConnection _DbConnection;
    private IDbCommand _DbCommand;
    private ConnectionStringSettings _DbConnectionString;
    private DbProviderFactory _DbFactory = null;
    private IDbTransaction _DbTransaction = null;
    private IDbDataAdapter _DbDataAdapter = null;
    /// <summary>
    /// Creates a new instance of CRMDbClient
    /// </summary>
    /// <param name="CurrentConnectionString"></param>
    public CrmDbClient(ConnectionStringSettings CurrentConnectionString)
    {
    _DbConnectionString = CurrentConnectionString;
    _DbFactory = DbProviderFactories.GetFactory(CurrentConnectionString.ProviderName);
    _DbConnection = _DbFactory.CreateConnection();
    _DbConnection.ConnectionString = CurrentConnectionString.ConnectionString;
    _DbCommand = _DbConnection.CreateCommand();
    _DbDataAdapter = _DbFactory.CreateDataAdapter();
    _DbDataAdapter.SelectCommand = _DbCommand;
    OpenConnection();
    }
    /// <summary>
    /// Destroy the current instance
    /// </summary>
    public void Dispose()
    {
    CloseConnection();
    _DbCommand.Dispose();
    _DbConnection.Dispose();
    _DbConnectionString = null;
    _DbDataAdapter = null;
    _DbFactory = null;
    _DbTransaction = null;
    }
    ~CrmDbClient()
    {
    GC.Collect();
    }
    #region Properties
    /// <summary>
    /// Gets or sets the command timeout in seconds
    /// </summary>
    public int CommandTimeout
    {
    get { return _DbCommand.CommandTimeout; }
    set { _DbCommand.CommandTimeout = value; }
    }
    /// <summary>
    /// Gets the database provider
    /// </summary>
    public string DataBaseProvider
    {
    get{return _DbConnectionString.ProviderName;}
    }
    /// <summary>
    /// Gets or set the
    /// </summary>
    public int ConnectionTimeout
    {
    get { return _DbConnection.ConnectionTimeout; }
    }
    #endregion
    /// <summary>
    /// Begins transaction
    /// </summary>
    public void BeginTransaction()
    {
    _DbCommand.Transaction = _DbTransaction = _DbConnection.BeginTransaction();
    }
    /// <summary>
    /// Commit transaction
    /// </summary>
    public void CommitTransaction()
    {
    if (_DbTransaction != null)
    {
    _DbTransaction.Commit();
    _DbTransaction.Dispose();
    _DbTransaction = null;
    _DbCommand.Transaction = null;
    }
    else
    {
    throw new CrmDbClientException("BeginTransaction must be called before commit or rollback. No open transactions found");
    }
    }
    /// <summary>
    /// Rollbacks transaction
    /// </summary>
    public void RollbackTransaction()
    {
    try
    {
    _DbTransaction.Rollback();
    }
    catch (InvalidOperationException invexcept)
    {
    throw new CrmDbClientException(invexcept.Message, invexcept);
    }
    catch (Exception e)
    {
    throw new CrmDbClientException(e.Message, e);
    }
    finally
    {
    //dispose _dbTransaction
    if (_DbTransaction != null)
    _DbTransaction.Dispose();
    _DbTransaction = null;
    }
    }
    /// <summary>
    /// Creates a generic parameter
    /// </summary>
    /// <param name="ParameterName">Represents the prameter's name</param>
    /// <param name="ParameterValue">Represents the parameter's value</param>
    /// <returns>IDbDataParameter</returns>
    private IDbDataParameter CreateParameter(string ParameterName,object ParameterValue)
    {
    IDbDataParameter p = _DbCommand.CreateParameter(); //create the command using the DBCommand
    p.Value = ParameterValue;
    p.ParameterName = ParameterName ;
    return p;
    }
    /// <summary>
    /// Open the connection with de server
    /// </summary>
    private void OpenConnection()
    {
    if (_DbConnection.State != ConnectionState.Open)
    _DbConnection.Open();
    }
    /// <summary>
    /// Closes the connection with the server
    /// </summary>
    private void CloseConnection()
    {
    if (_DbConnection.State != ConnectionState.Closed)
    _DbConnection.Close();
    }
    /// <summary>
    /// Executes a scalar query
    /// </summary>
    /// <param name="sql">Represents the query text</param>
    /// <param name="CmdType">Represents the command type</param>
    /// <returns>Object</returns>
    public object ExecuteScalarQuery(string QueryText,CommandType CmdType)
    {
    _DbCommand.CommandText = QueryText; //set que querytext
    _DbCommand.CommandType = CmdType;
    OpenConnection();
    object val = _DbCommand.ExecuteScalar(); //runs que query
    _DbCommand.Parameters.Clear();
    //CloseConnection();
    return val;
    }
    /// <summary>
    /// Executes a parametred scalar query
    /// </summary>
    /// <param name="QueryText">Query text</param>
    /// <param name="Parameters">Parameters list</param>
    /// <param name="CmdType">Command type</param>
    /// <returns></returns>
    public object ExecuteScalarQuery(string QueryText, Dictionary<string, object> Parameters, CommandType CmdType)
    {
    _DbCommand.CommandText = QueryText;
    _DbCommand.CommandType = CommandType.Text;
    _DbCommand.Parameters.Clear(); //clear parameters
    foreach (KeyValuePair<string, object> k in Parameters)
    {
    _DbCommand.Parameters.Add(CreateParameter(k.Key, k.Value));
    }
    OpenConnection();
    object val = _DbCommand.ExecuteScalar();
    _DbCommand.Parameters.Clear(); //clear parameters
    return val;
    }
    /// <summary>
    /// Executes a query and retourns the result into a datatable.
    /// </summary>
    /// <param name="QueryText">Query text</param>
    /// <param name="CmdType">Command type</param>
    /// <returns>Datatable containing the result</returns>
    public DataTable ExecuteReaderQuery(string QueryText, CommandType CmdType)
    {
    DataSet myDs = new DataSet();
    _DbCommand.CommandText = QueryText;
    _DbCommand.CommandType = CmdType;
    OpenConnection();
    _DbDataAdapter.Fill(myDs);
    return myDs.Tables[0];
    }
    /// <summary>
    /// Executes a parametred query and retourns the result into a datatable
    /// </summary>
    /// <param name="QueryText">Query text</param>
    /// <param name="QueryParameters">Command type</param>
    /// <param name="CmdType">Parameters list</param>
    /// <returns></returns>
    public DataTable ExecuteReaderQuery(string QueryText, Dictionary<string, object> QueryParameters, CommandType CmdType)
    {
    _DbDataAdapter.SelectCommand.Parameters.Clear();
    foreach (KeyValuePair<string, object> k in QueryParameters)
    {
    _DbDataAdapter.SelectCommand.Parameters.Add(CreateParameter(k.Key, k.Value));
    }
    DataTable val = this.ExecuteReaderQuery(QueryText,CmdType);
    _DbCommand.Parameters.Clear(); //clear parameters
    return val;
    }
    /// <summary>
    /// Executes a query and retourns affected rows number
    /// </summary>
    /// <param name="QueryText">Query text</param>
    /// <param name="CmdType">Command Type</param>
    /// <returns></returns>
    public int ExecuteNonQuery(string QueryText, CommandType CmdType)
    {
    _DbCommand.CommandText = QueryText;
    _DbCommand.CommandType = CmdType;
    OpenConnection();
    return _DbCommand.ExecuteNonQuery();
    }
    /// <summary>
    /// Executes a parametred query and retourns affected rows number
    /// </summary>
    /// <param name="QueryText">Query text</param>
    /// <param name="QueryParameters">Query parameters</param>
    /// <param name="CmdType">Command type</param>
    /// <returns>Integer value representing affected rows</returns>
    public int ExecuteNonQuery(string QueryText, Dictionary<string, object> QueryParameters, CommandType CmdType)
    {
    _DbCommand.Parameters.Clear();
    foreach (KeyValuePair<string, object> k in QueryParameters)
    {
    _DbCommand.Parameters.Add(this.CreateParameter(k.Key, k.Value));
    }
    int val = this.ExecuteNonQuery(QueryText, CmdType);
    _DbCommand.Parameters.Clear();
    return val;
    }
    }
    }

Bonne journée

[ben_skywalker]

Ce que tu me propose m'a l'air fort prometteur je te remercie. (je laisse en non résolut le temps de faire les tests)

Une petite question l'utilisation du :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

/// <summary> </summary>

(je ne la connaissais pas) c'est pour avoir une explication détaillée de la fonction lorsque tu l'utilises dans ton code, c'est bien ça?

[Immobilis]

Hello,

Sinon, il y a aussi ce tuto qui montre comment utiliser plusieurs DAL: http://immobilis.developpez.com/tuto...mework/#LIII-C

A+

[ben_skywalker]

j'ai juste un petit problème avec vos 2 solutions c'est qu'elles utilise le fichier de configuration.
personnellement je fais comme si je ne savais pas ce qu'il y a derrière le site. ça peux être n'importe qu'elle base de donnée j'ai donc un formulaire qui me permet de stocker dans un fichier binaire les informations sur la base de données.

Lorsque je m'apprète à faire une requète, je récupère ces informations et j'ouvre ma BDD comme cela exemple avec MySQL:
(Pour avancer sur le développement c'est la base que j'ai choisi, maintenant je souhaite faire évoluer le projet de manière à ce qu'il accepte plusieurs type de BDD)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public MySqlConnection connect(string lIPServeur, string laBase, string leUser, string lePassword)
        {
            String sqlStr;
            sqlStr = MakeConnectionString(lIPServeur, laBase, leUser, lePassword);
            this.mysql = new MySqlConnection(sqlStr);
            try
            {
                this.mysql.Open();
                this.server = lIPServeur;
                this.password = lePassword;
                this.user = leUser;
                this.database = laBase;
                _isConnected = true;
            }
            catch (MySql.Data.MySqlClient.MySqlException e)
            {
                System.Diagnostics.Debug.WriteLine("Exception : " + e);
                _isConnected = false;
            }
            return this.mysql;
        }

ma fonction MakeConnectionString :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
private string MakeConnectionString(string lIPServeur, string laBase, string leUser, string lePassword)
        {
            String cxStr;
 
            cxStr = "SERVER=" + lIPServeur + ";DATABASE=" + laBase + ";User id=" + leUser + ";PWD=" + lePassword + ";";
 
            return cxStr;
        }

donc si je ne me trompe pas, je n'écrit rien dans le fichier de webconfig...
Je rappel que dans mon cas, le serveur de BDD n'est pas connue, je souhaite pouvoir déployer l'application aussi bien chez moi que chez mes parents ou chez des amis et qu'il peuvent utiliser n'importe qu'elle type de SGBD

Donc sauf s'il existe une méthode pour écrire de manière dynamique dans le fichier webconf (chose je ne sais pas mais je vais chercher ça tout suite après avoir poster ce message^^) vos solutions ne paraisse plus convenir après avoir lut et essayer de comprendre le code ^^

toute fois si vous avez d'autre idée ou des piste sur l'écriture dans le webconf je suis preneur^^

[bossun]

Bon, si tu ne connais pas la base de données, tu as 2 problèmes.

1.- tu dois écrie du sql pour tous les types de base de de données en respectant les particularité de chaque système
2.- une chaine de connexion pour sqlserver est différente d'une chaine pour mysql. Donc tu dois faire un test avec toutes les variantes de chaines de connexion pour voir quelle base est la bonne.

[ben_skywalker]

1.- tu dois écrie du sql pour tous les types de base de de données en respectant les particularité de chaque système

Cela ne m'effrais pas, c'est déjà fait pour MSSQL et MYSQL il n'y a que "My" qui change entre les 2 je code mes requêtes de manière propre au langage SQL de base et me sert pas de spécificité particulière je n'en ai généralement pas l'utilité
exemple MySqlCommand au lieu de SqlCommand... (au incertitude de majuscule près, merci intelisens )

2.- une chaine de connexion pour sqlserver est différente d'une chaine pour mysql. Donc tu dois faire un test avec toutes les variantes de chaines de connexion pour voir quelle base est la bonne.

Là aussi j'en ai une qui fonctionne, ce n'est pas le problème...

Ce que je souhaite arrivé à faire c'est suivant le paramétrage de l'utilisateur, nom du serveur / @ IP / instance / nom d'utilisateur / mot de passe, ce serais d'ajouté dans le web.config les données de création de chaîne, dans le pire des cas un switch/case peux me permettre de tester les variante de chaine pour chaque type de base et trouver celle qui corresponds à la configuration du site, avant de l'insérer dans le web.config.

[Immobilis]

j'ai juste un petit problème avec vos 2 solutions c'est qu'elles utilise le fichier de configuration.

C'est juste un faux problème.

Dans l'exemple que te donne bossun il utilise une IDbConnection. Il s'agit d'une interface implémentée par les objets qui te permettent d'accéder à une base de donnée. L'avantage c'est qu'il n'a qu'à changer la chaine de connection son code fonctionnera toujours avec la même DAL.

Dans mon exemple, le code utilise une DAL en fonction d'un paramètre d'entrée. La base de donées sous-jacente peut être un fichier texte, excel, Access, SQL, Oracle, peu importe. Il y a une DAL par SGBDD.

L'utilisation d'une chaîne de connection peut être géré de manière dynamique. L'emplacement de cette information peut être le fichier de configuration, un web service, etc. mais cela n'a pas d'importance et surtout aucun rapport avec la DAL. La DAL attend une chaine de connection. Peu importe la façon dont tu la lui procures. L'essentiel étant que tu ne lui donne pas une chaine MySQL pour une base de données SQL Server.

A+

[ben_skywalker]

ok j'ai mal interprété ce que je voyais alors désolé je vais plancher la dessus à tête reposée et demanderais un coup de main, si besoins.

en tout cas merci pour les précisions

[Immobilis]

Je croyais que tu faisais

comme si je ne savais pas ce qu'il y a derrière le site. ça peux être n'importe qu'elle base de donnée

Or dans la signature de ton constructeur tu passes un "DBType"??? public CrmDbClient(string DBType, string ...). En fait, contrairement à ce que tu dis, quand tu instancies ta classe "CrmDbClient" tu sais déjà tout!! Tu n'as donc aucun intérêt à utiliser autre chose que le framework et à ne pas utiliser autre chose que DbProviderFactories... Tu n'as besoin que d'un générateur de chaînes de connections (pas un générateur de connections, juste les chaînes).

Sinon, tu ne résous pas le premier des deux problèmes:

tu as 2 problèmes.
1.- tu dois écrie du sql pour tous les types de base de de données en respectant les particularité de chaque système

Si tu gère des "millions de tuples" il va forcement falloir optimiser. C'est un peu contraire à une logique très générique. Comment comptes-tu adapter tes requêtes en fonction des types de DBDD?

@bossun, honnêtement tu te compliques la vie et tu prends des risques en créant par avance des objets dont tu n'as pas forcement besoin. Par exemple, ton constructeur va créer un dataadapter. Il est inutile si je ne veux que appeler la méthode "ExecuteScalarQuery".

De plus, ton implémentation d'un objet disposable est incorrecte. Jette un oeil ici: http://msdn.microsoft.com/fr-fr/magazine/cc163392.aspx.

Enfin, l'utilisation d'un DataAdapter pour la lecture en avant seulement d'une base de données est juste un tueur de performances (surtout si il y a des millions de tuples). Il faut renvoyer un IDataReader: http://msdn.microsoft.com/fr-fr/libr...atareader.aspx.

Un conseil, utilisez le Framework.

A+

[ben_skywalker]

Je croyais que tu faisais Or dans la signature de ton constructeur tu passes un "DBType"??? public CrmDbClient(string DBType, string ...). En fait, contrairement à ce que tu dis, quand tu instancies ta classe "CrmDbClient" tu sais déjà tout!! Tu n'as donc aucun intérêt à utiliser autre chose que le framework et à ne pas utiliser autre chose que DbProviderFactories... Tu n'as besoin que d'un générateur de chaînes de connections (pas un générateur de connections, juste les chaînes).

Pour moi mon DBType == ("MYSQL" || "MSSQL")
Lorsque tu me parle de DbProviderFactories j'ai bien vue des exemple pour lesquelles il est utilisé, récupéré via la chaîne de connexion OR lorsque j'essais de le récupérer, moi ça me génère une exeption comme indiquer précédemment... Voilà pourquoi je ne l'utilise pas à moins d'avoir un exemple de définition dans une chaîne de connexion chose que pour le moment, en aillant rechercher sur différent site je n'est Pas trouvé, je ne saurais utilisé quelque chose qui me fait planter mon programme!

Sinon, tu ne résous pas le premier des deux problèmes:Si tu gère des "millions de tuples" il va forcement falloir optimiser. C'est un peu contraire à une logique très générique. Comment comptes-tu adapter tes requêtes en fonction des types de DBDD?

j'ai tester l'intégralité de mes requêtes sur MSSQL et MySQL toutes sont compatible!
voici un exemple que de requête que je fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
string req = "INSERT INTO groups(champ1, champ2, champ3, champ4)";
req += string.format("VALUES({0},{1},{2},{3}", MonChamp1, MonChamp2, MonChamp3, MonChamp4);";

et a nouveau comme écrit plus haut, pas de problème de compatibilité. Maintenant je ne doute pas qu'il existe quelque part un type de base de données n'acceptant ce type de requêtes mais pour le moment ce n'est pas le problème! ce que je veux c'est vraiment m'affranchir des sqlconnection ou mysqlconnection...

Pour moi et pour le moment au vue des tests réalisé la solution de bossun est fonctionnel! il me resterais juste à la modifier car j'aime pas trop l'utilisation des DataTable ^^ enfin surtout que je ne les ai jamais utilisé j'ai préféré les DataReader plus simple à parcourir

Mais au vue des différents commentaires, je vais vraiment me pencher sur l'interface