Est-il nécessaire de fermer manuellement et de supprimer SqlDataReader?

Je travaille avec le code hérité ici et il existe de nombreuses instances de SqlDataReader qui ne sont jamais fermées ou éliminées. La connexion est fermée mais je ne suis pas sûr qu’il soit nécessaire de gérer le lecteur manuellement.

Cela pourrait-il ralentir la performance?

Essayez d’éviter d’utiliser des lecteurs comme celui-ci:

 SqlConnection connection = new SqlConnection("connection ssortingng"); SqlCommand cmd = new SqlCommand("SELECT * FROM SomeTable", connection); SqlDataReader reader = cmd.ExecuteReader(); connection.Open(); if (reader != null) { while (reader.Read()) { //do something } } reader.Close(); // < - too easy to forget reader.Dispose(); // <- too easy to forget connection.Close(); // <- too easy to forget 

Au lieu de cela, enveloppez-les en utilisant des instructions:

 using(SqlConnection connection = new SqlConnection("connection ssortingng")) { connection.Open(); using(SqlCommand cmd = new SqlCommand("SELECT * FROM SomeTable", connection)) { using (SqlDataReader reader = cmd.ExecuteReader()) { if (reader != null) { while (reader.Read()) { //do something } } } // reader closed and disposed up here } // command disposed here } //connection closed and disposed here 

L'instruction using assurera l'élimination correcte de l'object et la libération des ressources.

Si vous oubliez, vous laissez le nettoyage à la corbeille à papier, ce qui peut prendre un certain temps.

Notez que la disposition d’un SqlDataReader instancié à l’aide de SqlCommand.ExecuteReader () ne ferme pas / ne supprime pas la connexion sous-jacente.

Il y a deux modèles communs. Dans le premier cas, le lecteur est ouvert et fermé dans le cadre de la connexion:

 using(SqlConnection connection = ...) { connection.Open(); ... using(SqlCommand command = ...) { using(SqlDataReader reader = command.ExecuteReader()) { ... do your stuff ... } // reader is closed/disposed here } // command is closed/disposed here } // connection is closed/disposed here 

Parfois, il est pratique d’avoir une méthode d’access aux données pour ouvrir une connexion et renvoyer un lecteur. Dans ce cas, il est important que le lecteur renvoyé soit ouvert à l’aide de CommandBehavior.CloseConnection, afin que la fermeture / suppression du lecteur ferme la connexion sous-jacente. Le motif ressemble à ceci:

 public SqlDataReader ExecuteReader(ssortingng commandText) { SqlConnection connection = new SqlConnection(...); try { connection.Open(); using(SqlCommand command = new SqlCommand(commandText, connection)) { return command.ExecuteReader(CommandBehavior.CloseConnection); } } catch { // Close connection before rethrowing connection.Close(); throw; } } 

et le code appelant doit simplement disposer le lecteur ainsi:

 using(SqlDataReader reader = ExecuteReader(...)) { ... do your stuff ... } // reader and connection are closed here. 

Pour être sûr, enroulez chaque object SqlDataReader dans une instruction using .

Enveloppez simplement votre SQLDataReader avec l’instruction “using”. Cela devrait prendre en charge la plupart de vos problèmes.