É necessário fechar e descartar manualmente o SqlDataReader?

Estou trabalhando com código legado aqui e há muitas instâncias SqlDataReaderque nunca são fechadas ou descartadas. A conexão está fechada, mas não tenho certeza se é necessário gerenciar o leitor manualmente.

Isso pode causar uma desaceleração no desempenho?

Tente evitar o uso de leitores 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

Em vez disso, envolva-os em instruções:

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

A instrução using irá garantir o descarte correto do objeto e a liberação de recursos.

Se você esquecer, está deixando a limpeza para o coletor de lixo, o que pode demorar um pouco.

Observe que descartar um SqlDataReader instanciado usando SqlCommand.ExecuteReader () não fechará / descartará a conexão subjacente.

Existem dois padrões comuns. Na primeira, o leitor é aberto e fechado no âmbito da conexão:

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

Às vezes, é conveniente ter um método de acesso a dados para abrir uma conexão e retornar um leitor. Nesse caso, é importante que o leitor retornado seja aberto usando CommandBehavior.CloseConnection, para que fechar / descartar o leitor feche a conexão subjacente. O padrão é mais ou menos assim:

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 o código de chamada precisa apenas dispor o leitor assim:

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

Para ser seguro, envolva cada objeto SqlDataReader em uma instrução using .

Apenas envolva seu SQLDataReader com a instrução "using". Isso deve cuidar da maioria dos seus problemas.