SQLDataReader object when declared in a foreach loop - garbage-collection

Question

This is something I return to from time to time, but have not yet found a definitive answer. Hopefully I will get it before Microsoft legacies the language (joking... kinda)...
This is almost certainly wrong, but this is how I've been retrieving records from SQLServer... I am passing each row to it's caller as a IDataRecord and using an SQLDataREader object to iterate through it. I have read that the datareader should be closed after use, if not declared in a using statement. Should I be closing this one?
My SQLDataReader is declared in a foreach loop like this...
IEnumerable<IDataRecord> dataset = Select("SELECT Topic FROM Topics WHERE pti=" + pid + " and Ignore = 0");
foreach (SqlDataReader reader in dataset )
{
string topic = reader.GetString(0);
//... do something
}
My db call:
public IEnumerable<IDataRecord> Select(string sql, List<SqlParameter> sparams = null)
{
using (SqlConnection cn = new SqlConnection(ConnString()))
{
cn.Open();
using (SqlCommand cmd = new SqlCommand(sql, cn))
{
if (sparams != null)
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddRange(sparams.ToArray());
}
else
{
cmd.CommandType = CommandType.Text;
}
using (SqlDataReader rdr = cmd.ExecuteReader())
{
if (rdr != null && rdr.FieldCount > 0)
{
while (rdr.Read())
{
yield return rdr;
}
}
}
}
cn.Close();
}
}

Answer 1

There's actually nothing to close. The closable reader object in your code is the one that uses the connection, but it's closed automatically by the using statement in your Select method.
I think the way you did it is pretty uncommon. If you're able to change the method signature, you could simply return a List<> by doing a cast and, removing the yield like this:
public List<IDataRecord> Select(string sql , List<SqlParameter> sparams = null)
{
using (SqlConnection cn = new SqlConnection (ConnectionString))
{
cn.Open ( );
using (SqlCommand cmd = new SqlCommand (sql , cn))
{
if (sparams != null)
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddRange (sparams.ToArray ( ));
}
else
{
cmd.CommandType = CommandType.Text;
}
using (SqlDataReader rdr = cmd.ExecuteReader ( ))
{
return rdr.Cast<IDataRecord> ( ).ToList ( );
}
}
}
}
I've done this in a DB connection class. It's pretty straightforward, but post a comment if you have any questions:
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
namespace SqlToDb
{
public class SqlClientData
{
private string connectionstring;
public string ConnectionString { get => connectionstring; set => connectionstring = value; }
public SqlClientData(string connection_string)
{
ConnectionString = connection_string;
}
public T ExecuteScalar<T>(string queryString)
{
using (SqlConnection conn = new SqlConnection (ConnectionString))
{
using (SqlCommand cmd = new SqlCommand (queryString , conn))
{
try
{
conn.Open ( );
var result = cmd.ExecuteScalar ( );
if (Convert.IsDBNull (result) && typeof (T).IsValueType)
return default (T); // if the db value is null, but T is a value type, set T = the default value of the type.
else
return (T) (result);
}
finally
{
conn.Close ( );
}
}
}
}
public List<T> ExecScalarList<T>(string sql , bool exclude_nulls , bool replace_null_with_default)
{
using (SqlConnection conn = new SqlConnection (ConnectionString))
{
using (SqlCommand cmd = new SqlCommand (sql , conn))
{
conn.Open ( );
using (SqlDataReader rdr = cmd.ExecuteReader ( ))
{
var mylist = new List<T> { };
while (rdr.Read ( ))
{
if (!Convert.IsDBNull (rdr[0]) || (exclude_nulls == false && replace_null_with_default == false))
{
mylist.Add ((T) Convert.ChangeType (rdr[0] , typeof (T)));
}
else
{
if (exclude_nulls == false)
{
if (replace_null_with_default == true) mylist.Add (default (T)); // returns the default for the type... not null
}
}
}
return mylist;
}
}
}
}
public List<IDataRecord> ExecReader(string sql)
{
using (SqlConnection conn = new SqlConnection (ConnectionString))
{
using (SqlCommand cmd = new SqlCommand (sql , conn))
{
conn.Open ( );
using (SqlDataReader rdr = cmd.ExecuteReader ( ))
{
return rdr.Cast<IDataRecord> ( ).ToList ( );
}
}
}
}
public int ExecNonQuery(string sql)
{
int result = 0;
using (SqlConnection cn = new SqlConnection (ConnectionString))
{
using (SqlCommand cmd = new SqlCommand (sql , cn))
{
cmd.CommandType = CommandType.Text; // or CommandType.StoredProcedure
cn.Open ( );
try
{
result = (Int32) cmd.ExecuteNonQuery ( ); //returns the number of rows affected
}
finally
{
cn.Close ( );
}
}
}
return result;
}
}
}