¿Es necesario cerrar manualmente y deshacerse de SqlDataReader?

Question

Estoy trabajando con código heredado aquí y hay muchas instancias de SqlDataReader que nunca se cierran o eliminan. La conexión está cerrada, pero no estoy seguro de si es necesario administrar el lector manualmente.

¿Podría esto causar una desaceleración en el rendimiento?

Answer 1

Trate de evitar el uso de lectores de esta manera:

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 

En su lugar, se envuelven en 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 instrucción using asegurarán una eliminación correcta del objeto y liberación de recursos.

Si lo olvida, estará dejando la limpieza al recolector de basura, lo que podría llevar un tiempo.

Answer 2

Para estar seguro, ajuste cada objeto SqlDataReader en using statement.

Answer 3

Simplemente ajuste su SQLDataReader con la instrucción "using". Eso debería encargarse de la mayoría de sus problemas.

Answer 4

Tenga en cuenta que eliminar un SqlDataReader instanciado mediante SqlCommand.ExecuteReader() no cerrar/eliminar la conexión subyacente.

Hay dos patrones comunes. En la primera, el lector se abre y se cierra en el ámbito de la conexión:

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 veces es conveniente tener un método de acceso de datos abierta una conexión y devuelve un lector. En este caso, es importante que el lector devuelto se abra usando CommandBehavior.CloseConnection, de modo que al cerrar/eliminar el lector se cierre la conexión subyacente. El patrón se ve algo como esto:

y el código de llamada sólo necesita disponer el lector de este modo:

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