c# - primero - ¿Es necesario cerrar y eliminar manualmente SqlDataReader?

uso del datareader c#

Question

Estoy trabajando con el 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

Intenta evitar el uso de lectores como este:

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 cambio, envuélvalos en declaraciones de uso:

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 declaración using asegurará la eliminación correcta del objeto y la 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 una instrucción de uso .

Answer 3

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

Answer 4

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

Hay dos patrones comunes. En el primero, el lector se abre y se cierra dentro del alcance 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 a datos para abrir una conexión y devolver 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 así:

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

y el código de llamada solo necesita deshacerse del lector así:

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