c# - example - SqlDataReader vs SqlDataAdapter: ¿cuál tiene el mejor rendimiento para devolver un DataTable?

sqldataadapter fill datatable

Question

Quiero saber cuál tiene el mejor rendimiento para devolver un DataTable . Aquí para SqlDataReader yo uso DataTable.Load(dr)

Usando SqlDataReader :

public static DataTable populateUsingDataReader(string myQuery)
{
DataTable dt = new DataTable();
using (SqlConnection con = new SqlConnection(constring))
{
SqlCommand cmd = new SqlCommand(myQuery, con);
con.Open();
SqlDataReader dr = null;
dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
if (dr.HasRows)
{
dt.Load(dr);
}
return dt;
}
}

utilizando SqlDataAdapter :

public DataTable populateUsingDataAdapter(string myQuery)
{
SqlDataAdapter dap = new SqlDataAdapter(myQuery,cn);
DataSet ds = new DataSet();
dap.Fill(ds);
return ds.Tables[0];
}

Answer 1

Además de la solución seleccionada, me gustaría agregar que:

Usando el DataReader, no necesita saber qué tipo de DbConnection tiene.

Todo lo que necesita es una instancia que implemente IDbConnection, con la que puede usar "connection.CreateCommand" y luego "dbCommand.ExecuteReader" y luego dataTable.Load.

Pero cuando use DataAdapter necesitará saber qué conexión se usa (es decir, oracle, sqlserver, etc.)

(No es relevante para el iniciador de hilos, pero aterricé aquí usando g ** gle mientras buscaba este tema).

Answer 2

La diferencia será despreciable, por lo que probablemente sea mejor usar la versión más concisa: SqlDataAdapter.Fill .

SqlDataReader.Fill crea internamente una clase interna LoadAdapter (derivada de DataAdapter ), y llama a su método Fill : el rendimiento será muy similar a SqlDataAdapter.Fill(DataTable) .

Habrá algunas pequeñas diferencias en la inicialización / validación de los argumentos, pero a medida que aumente el número de filas, esto será cada vez menos significativo.

Tenga en cuenta también que su segunda muestra debe modificarse para que sea comparable con la primera:

public DataTable populateUsingDataAdapter(string myQuery)
{
using (SqlConnection con = new SqlConnection(constring))
{
SqlDataAdapter dap = new SqlDataAdapter(myQuery,con);
DataTable dt = new DataTable();
dap.Fill(dt);
return dt;
}
}

Answer 3

Esta pregunta , y más específicamente, esta respuesta sugiere que su segundo ejemplo es más rápido. Ciertamente no es un punto de referencia exhaustivo, pero es una prueba interesante.

Al reflejar el código fuente de DataTable muestra que llamar a DataTable.Load () en realidad crea una subclase de DataAdapter interna llamada LoadAdapter y llama al método Fill() de DataAdapter . SqlDataAdapter hace la mayor parte de su trabajo de carga en el mismo lugar exacto.

Más importante aún, tiendo a favorecer el segundo ejemplo de legibilidad. Ninguno de los ejemplos se compara con el acceso rápido proporcionado por el uso directo del DataReader , por lo que optaría por el código más limpio.

Answer 4

SqlDataReader ha sido históricamente mucho más rápido que SqlDataAdapter . Es posible que se hayan realizado mejoras en .NET 4.5, pero dudo que haya mejorado lo suficiente como para superar el rendimiento del DataReader.

Answer 5

SqlDataReader será más rápido que SQlDataAdapter porque funciona en un estado conectado, lo que significa que el primer resultado se devuelve de la consulta tan pronto como esté disponible.