Czy konieczne jest ręczne zamknięcie i usunięcie SqlDataReader?

Pracuję tutaj ze starszym kodem i jest wiele jego przypadków SqlDataReader, które nigdy nie są zamykane ani usuwane. Połączenie jest zamknięte, ale nie jestem pewien, czy konieczne jest ręczne zarządzanie czytnikiem.

Czy może to spowodować spowolnienie wydajności?

Staraj się unikać takich czytników:

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

Zamiast tego opakuj je w instrukcje:

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

Oświadczenie o korzystaniu zapewni prawidłowe usunięcie przedmiotu i uwolnienie zasobów.

Jeśli zapomnisz, zostawisz sprzątanie śmietnikowi, co może chwilę potrwać.

Należy zauważyć, że usunięcie SqlDataReader utworzonego za pomocą SqlCommand.ExecuteReader () nie spowoduje zamknięcia / usunięcia podstawowego połączenia.

Istnieją dwa wspólne wzorce. W pierwszym czytnik jest otwierany i zamykany w ramach połączenia:

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

Czasami wygodnie jest mieć metodę dostępu do danych, otwierającą połączenie i zwracającą czytnik. W takim przypadku ważne jest, aby zwrócony czytnik został otwarty za pomocą CommandBehavior.CloseConnection, aby zamknięcie / usunięcie czytnika zamknęło podstawowe połączenie. Wzór wygląda mniej więcej tak:

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

a kod wywołujący musi po prostu pozbyć się czytnika w ten sposób:

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

Aby być bezpiecznym, zawiń każdy obiekt SqlDataReader instrukcją using .

Po prostu zawiń swój SQLDataReader instrukcją „using”. To powinno rozwiązać większość twoich problemów.