È necessario chiudere e smaltire manualmente SqlDataReader?

Sto lavorando con il codice legacy qui e ci sono molte istanze SqlDataReaderche non vengono mai chiuse o eliminate. La connessione è chiusa ma non sono sicuro se sia necessario gestire manualmente il lettore.

Questo potrebbe causare un rallentamento delle prestazioni?

Cerca di evitare di usare lettori come questo:

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

Invece, avvolgili nelle istruzioni using:

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 dichiarazione using garantirà il corretto smaltimento dell'oggetto e la liberazione delle risorse.

Se dimentichi, stai lasciando la pulizia al netturbino, che potrebbe richiedere del tempo.

Si noti che l'eliminazione di un SqlDataReader istanziato utilizzando SqlCommand.ExecuteReader () non chiuderà / eliminerà la connessione sottostante.

Esistono due modelli comuni. Nella prima, il lettore viene aperto e chiuso nell'ambito della connessione:

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

A volte è conveniente che un metodo di accesso ai dati apra una connessione e restituisca un lettore. In questo caso è importante che il lettore restituito venga aperto utilizzando CommandBehavior.CloseConnection, in modo che la chiusura / eliminazione del lettore chiuderà la connessione sottostante. Il modello è simile a questo:

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;
    }
}

e il codice chiamante deve solo disporre il lettore così:

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

Per sicurezza, racchiudi ogni oggetto SqlDataReader in un'istruzione using .

Metti semplicemente il tuo SQLDataReader nell'istruzione "using". Questo dovrebbe occuparsi della maggior parte dei tuoi problemi.