Est-il nécessaire de fermer et d'éliminer manuellement SqlDataReader ?

Question

Je travaille avec un code ancien et il y a de nombreuses instances de SqlDataReader qui ne sont jamais fermés ou éliminés. La connexion est fermée, mais je ne sais pas s'il est nécessaire de gérer le lecteur manuellement.

Cela peut-il entraîner un ralentissement des performances ?

Answer 1

Essayez d'éviter d'utiliser des lecteurs de ce type :

SqlConnection connection = new SqlConnection("connection string");
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, il faut les envelopper dans des déclarations d'utilisation :

using(SqlConnection connection = new SqlConnection("connection string"))
{

    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

La déclaration d'utilisation garantira l'élimination correcte de l'objet et la libération des ressources.

Si vous l'oubliez, vous laissez le soin au ramasseur d'ordures de faire le ménage, ce qui peut prendre un certain temps.

Answer 2

Notez que l'élimination d'un SqlDataReader instancié à l'aide de SqlCommand.ExecuteReader() aura pour effet de no fermer/éliminer la connexion sous-jacente.

Il existe deux modèles courants. Dans le premier, 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

Il est parfois pratique de demander à une méthode d'accès aux données d'ouvrir une connexion et de renvoyer un lecteur. Dans ce cas, il est important que le lecteur renvoyé soit ouvert à l'aide de CommandBehavior.CloseConnection, de sorte que la fermeture/disposition du lecteur entraîne la fermeture de la connexion sous-jacente. Le modèle ressemble à ceci :

public SqlDataReader ExecuteReader(string 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 n'a plus qu'à se débarrasser du lecteur :

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

Answer 3

Pour plus de sécurité, enveloppez chaque objet SqlDataReader dans un objet utiliser la déclaration .

Answer 4

Enveloppez simplement votre SQLDataReader avec l'instruction "using". Cela devrait résoudre la plupart de vos problèmes.