Apakah SqlDataReader harus ditutup dan dibuang secara manual?

Saya bekerja dengan kode lama di sini dan ada banyak contoh SqlDataReaderyang tidak pernah ditutup atau dibuang. Sambungan ditutup tetapi, saya tidak yakin apakah perlu mengelola pembaca secara manual.

Mungkinkah ini menyebabkan perlambatan kinerja?

Cobalah untuk menghindari penggunaan pembaca seperti ini:

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

Sebagai gantinya, bungkus dengan menggunakan pernyataan:

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

Pernyataan penggunaan akan memastikan pembuangan objek yang benar dan membebaskan sumber daya.

Jika Anda lupa, maka Anda menyerahkan pembersihan ke pengumpul sampah, yang bisa memakan waktu cukup lama.

Perhatikan bahwa membuang SqlDataReader yang dibuat menggunakan SqlCommand.ExecuteReader () tidak akan menutup / membuang koneksi yang mendasarinya.

Ada dua pola umum. Yang pertama, pembaca dibuka dan ditutup dalam ruang lingkup koneksi:

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

Terkadang nyaman untuk memiliki metode akses data membuka koneksi dan mengembalikan pembaca. Dalam hal ini, pembaca yang dikembalikan harus dibuka menggunakan CommandBehavior.CloseConnection, sehingga menutup / membuang pembaca akan menutup koneksi yang mendasarinya. Polanya terlihat seperti ini:

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

dan kode panggilan hanya perlu membuang pembaca sebagai berikut:

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

Untuk amannya, bungkus setiap objek SqlDataReader dalam pernyataan using .

Cukup bungkus SQLDataReader Anda dengan pernyataan "using". Itu seharusnya menangani sebagian besar masalah Anda.