Muss SqlDataReader manuell geschlossen und entsorgt werden?

Ich arbeite hier mit Legacy-Code und es gibt viele Instanzen SqlDataReader, die niemals geschlossen oder entsorgt werden. Die Verbindung ist geschlossen, aber ich bin nicht sicher, ob es notwendig ist, den Reader manuell zu verwalten.

Könnte dies zu einer Leistungsverlangsamung führen?

Vermeiden Sie solche Leser:

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

Schließen Sie sie stattdessen mit Anweisungen ein:

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

Die using-Anweisung stellt die korrekte Entsorgung des Objekts und die Freisetzung von Ressourcen sicher.

Wenn Sie es vergessen, überlassen Sie die Reinigung dem Müllsammler, was eine Weile dauern kann.

Beachten Sie, dass das Entsorgen eines mit SqlCommand.ExecuteReader () instanziierten SqlDataReader die zugrunde liegende Verbindung nicht schließt / entsorgt.

Es gibt zwei gängige Muster. Im ersten Fall wird der Leser im Rahmen der Verbindung geöffnet und geschlossen:

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

Manchmal ist es praktisch, wenn eine Datenzugriffsmethode eine Verbindung öffnet und einen Leser zurückgibt. In diesem Fall ist es wichtig, dass der zurückgegebene Reader mit CommandBehavior.CloseConnection geöffnet wird, damit durch Schließen / Entsorgen des Readers die zugrunde liegende Verbindung geschlossen wird. Das Muster sieht ungefähr so ​​aus:

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

und der aufrufende Code muss den Leser nur so entsorgen:

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

Um sicher zu gehen, schließen Sie jedes SqlDataReader-Objekt in eine using-Anweisung ein .

Schließen Sie Ihren SQLDataReader einfach mit der Anweisung "using" ein. Das sollte sich um die meisten Ihrer Probleme kümmern.