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

Je travaille avec du code hérité ici et il existe de nombreuses instances SqlDataReaderqui ne sont jamais fermées ou supprimé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 entraîner un ralentissement des performances?

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

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, enveloppez-les dans des instructions 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 using assurera l'élimination correcte de l'objet et la libération des ressources.

Si vous oubliez, vous laissez le nettoyage au ramasse-miettes, ce qui peut prendre un certain temps.

Notez que la suppression d'un SqlDataReader instancié à l'aide de SqlCommand.ExecuteReader () ne fermera / supprimera pas la connexion sous-jacente.

Il existe deux modèles communs. 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

Parfois, il est pratique qu'une méthode d'accès aux données ouvre une connexion et renvoie 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(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 a juste besoin de disposer le lecteur ainsi:

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

Pour être sûr, enveloppez chaque objet SqlDataReader dans une instruction using .

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