Conception de wrapper de firebase database C #

Je conçois un wrapper de firebase database pour C #. Voici les deux options que j’ai:

Option A:

class DBWrapper:IDisposable { private SqlConnection sqlConn; public DBWrapper() { sqlConn = new SqlConnection("my connection ssortingng"); sqlConn.Open(); } public DataTable RunQuery(ssortingng Sql) { implementation...... } public Dispose() { if(sqlConn != null) sqlConn.Close(); } }

Option B:

 class DBWrapper { public DBWrapper() { } public DataTable RunQuery(ssortingng Sql) { SqlConnection sqlConn = new SqlConnection("my connection ssortingng"); .....implementation...... sqlConn.Close(); } }

Pour l’option Une connexion est ouverte lorsque la classe est instanciée. Ainsi, quel que soit le nombre d’appels de l’appelant à RunQuery, la connexion est toujours prête. Mais si l’application instancie DBWrapper plus tôt dans l’application, la connexion sera simplement ouverte et ne fera rien jusqu’à ce que l’application soit terminée. En outre, de nombreux DBWrapper pourraient être instanciés pendant l’exécution. Donc, c’est un peu gaspiller des ressources.

Pour l’option B, l’option A ne pose pas le problème, mais une nouvelle connexion doit être ouverte et fermée à chaque fois que l’appelant appelle RunQuery. Je ne sais pas à quel point cela va nuire à la performance.

S’il vous plaît partager votre expertise. Merci pour la lecture.

Pour des raisons de performances, vous ne voudrez certainement pas choisir Option B (du moins dans les cas que j’ai connus). Permettez-moi de vous suggérer l’option C:

 class DBWrapper:IDisposable { private SqlConnection sqlConn; public void EnsureConnectionIsOpen() { if (sqlConn == null) { sqlConn = new SqlConnection("my connection ssortingng"); sqlConn.Open(); } } public DataTable RunQuery(ssortingng Sql) { EnsureConnectionIsOpen(); implementation...... } public Dispose() { if(sqlConn != null) sqlConn.Close(); } }

Vous pouvez envisager d’utiliser le modèle singleton pour vous assurer qu’il n’y a qu’une seule instance de votre DBWrapper.

Quelques commentaires à considérer:

Dans l’approche où vous gérez une connexion (peut-être) longue vie, il est important de vérifier si la connexion est ouverte avant d’exécuter une requête. J’ai rencontré des problèmes auparavant où NETCF fermait les connexions inutilisées après un certain temps.

Dans l’approche où vous ouvrez une nouvelle connexion par requête, assurez-vous que votre connexion, vos commandes et (le cas échéant) vos lecteurs de données sont correctement encapsulés dans des instructions ou que des blocs try / finally + dispose () vous permettent de libérer des connexions et des verrous.

Bonne codage!

Le ramasse-miettes est déclenché dans des conditions assez complexes, mais il est généralement appelé lorsque la mémoire dépasse une limite. Il est également appelé périodiquement, mais la période n’est pas constante. Vous ne pouvez jamais être sûr du moment où le ramasse-miettes dispose exactement et par conséquent (dans une autre exécution) détruit l’object. Une chose dont vous pouvez être sûr est le fait que le ramasse-miettes ne disposera et ne détruira jamais l’object qui contient encore des références. Par exemple, un object référencé via des variables statiques sur la classe ne sera ni supprimé ni détruit.

L’option B est plus transactionnelle, ce qui a ses avantages. ADO.NET utilise le regroupement implicite de connexions, vous n’avez donc pas à vous soucier de la création fréquente de nouvelles instances de SqlConnection.

Vous devez déterminer si vous utilisez un modèle de données connecté ou déconnecté. comme la seconde approche se prête mieux à un modèle déconnecté.

Mais comme je l’ai dit plus haut, la mise en commun des connexions signifie qu’elle ne fait pratiquement aucune différence en termes pratiques.

Vous pourriez avoir une option C où la firebase database est ouverte à la demande dans RunQuery (si elle n’est pas ouverte) et fermée à la disposition (lors de l’ouverture). De cette façon, la firebase database n’est ouverte que si cela est vraiment nécessaire et ne sera ouverte qu’une fois.

Donc, en pseudo-code:

 class DBWrapper { public DBWrapper() { } SqlConnection sqlConn = null; public DataTable RunQuery(ssortingng Sql) { if(sqlConn == null) sqlConn = new SqlConnection("my connection ssortingng"); .....implementation...... } public Dispose() { if(sqlConn != null) sqlConn.Close(); } }

Notez également que le moment où Dispose est appelé n’est pas toujours directement après que l’object n’est plus nécessaire (par exemple, une variable de fonction après l’utilisation de la fonction). Autant que je sache, il sera exécuté lorsque le ramasse-miettes récupère l’object (ce qui n’est pas directement). Mais je ne suis pas totalement sûr de cela. Ce comportement peut également différer entre une application Web et une application non Web.