.net - net - mostrar datos de una tabla en mvc

¿El lector de datos es más rápido que el conjunto de datos al completar una tabla de datos? (8)

Que sería más rápido.

1) Looping un lector de datos y la creación de una tabla de datos poblada basada en filas y columnas personalizadas

2) O creando un objeto dataAdapter y simplemente (.Fill) ing datatable.

¿Sigue siendo cierto el rendimiento de un lector de datos con la creación dinámica de una tabla de datos?

Al igual que con muchas preguntas como esta, la respuesta es: depende.

Si no conoce la estructura de sus datos por adelantado y está creando TableAdapters sobre la marcha, entonces la DataTable dinámica sería más eficiente. Hay una buena cantidad de generación de código involucrada en la creación de un TableAdapter.

Sin embargo, si conoce la estructura de sus datos por adelantado, entonces la pregunta es: ¿Cuánta funcionalidad necesito?

Si necesita una implementación completa de CRUD, entonces se obtienen algunas eficiencias mediante el uso de un TableAdapter en lugar de escribir todo ese código CRUD usted mismo. Además, la implementación de TableAdapter es correcta (no excelente). Si necesita algo más eficiente, es mejor que utilice nHibernate u otro ORM.

Si no necesita una implementación completa de CRUD (es decir, esta es una solución de solo lectura) y conoce su estructura de datos por adelantado, entonces deberá probar la eficacia de una implementación de solo lectura de TableAdapter frente a una DataTable generada dinámicamente. . Si fuera un apostador, pondría mi dinero en la implementación de TableAdapter, ya que vincula los datos una vez y los lee varias veces.

El DataAdapter usa un DataReader debajo del capó para que su experiencia sea la misma.

El beneficio de DataAdapter es que eliminó una gran cantidad de código que necesitaría mantenimiento.

Este debate es un tema religioso, así que definitivamente mira a tu alrededor y decide qué funciona mejor para tu situación:

El lector de datos es más rápido. Y si usa 2.0+ probablemente no tenga que usar una tabla de datos. Puedes usar una lista genérica de tu objeto.

Es bueno tener DataReader cuando lo que necesita, por ejemplo, mostrar el progreso de la carga de datos. En DataSet no puedes hacer algo en medio de cargar datos.

Por otro lado, DataSet es un objeto todo en uno. Entonces DataSet es mucho más lento. DataReader puede darle impulso adicional en lugares en su código donde la operación de datos es muy lenta. En estos lugares, cámbielo de DataSet a DataReader. DataReader también ocupa menos espacio en la memoria.

Por supuesto, lleva más tiempo codificar un buen DataReader, pero vale la pena. Por ejemplo, cuando juegas con imágenes o música tomada desde la base de datos.

Más sobre este tema en MSDN Magazine

No puedo hablar sobre llenar una tabla de datos en sí, pero usar un lector de datos es el método de lectura más eficiente.

Su opción n. ° 1 sería más lenta. Sin embargo, hay una forma mejor de convertir un lector de datos en una tabla de datos que agregar filas personalizadas a mano:

DataTable dt = new DataTable(); using (SqlConnection conn = GetOpenSqlConnection()) using (SqlCommand cmd = new SqlCommand("SQL Query here", conn) using (IDataReader rdr = cmd.ExecuteReader()) { dt.Load(rdr); }

No puedo comentar la diferencia entre esto y el uso de .Fill() .

Suponiendo que realmente desea que todos los datos vuelvan de la base de datos, es casi seguro que el tiempo empleado en la base de datos y en la red disminuirá el tiempo que lleva en proceso completar las estructuras de datos en la memoria.

Sí, en algunos casos puede obtener un pequeño ahorro usando DataReader, y en particular si desea transmitir los datos, puede ser útil, pero si realmente lo necesita todo, me quedaría con el código más simple. Si cree que la población de DataSet está causando un problema de rendimiento significativo, perfórelo y luego intente mejorarlo.

DataReader la Read DataReader , que es un enfoque solo de reenvío, de una fila a la vez, que lee datos secuencialmente para que pueda obtener registros tan pronto como se leen al conectarse, será lo mejor para la memoria y actuación.

Dicho esto, entre los dos enfoques, encuentro que IDataAdapter.Fill mucho más rápido que DataTable.Load . Por supuesto, eso depende de las implementaciones. Aquí hay un punto de referencia entre los dos que publiqué aquí :

public DataTable Read1<T>(string query) where T : IDbConnection, new() { using (var conn = new T()) { using (var cmd = conn.CreateCommand()) { cmd.CommandText = query; cmd.Connection.ConnectionString = _connectionString; cmd.Connection.Open(); var table = new DataTable(); table.Load(cmd.ExecuteReader()); return table; } } } public DataTable Read2<S, T>(string query) where S : IDbConnection, new() where T : IDbDataAdapter, IDisposable, new() { using (var conn = new S()) { using (var da = new T()) { using (da.SelectCommand = conn.CreateCommand()) { da.SelectCommand.CommandText = query; da.SelectCommand.Connection.ConnectionString = _connectionString; DataSet ds = new DataSet(); //conn is opened by dataadapter da.Fill(ds); return ds.Tables[0]; } } } }

El segundo enfoque siempre superó al primero.

Stopwatch sw = Stopwatch.StartNew(); DataTable dt = null; for (int i = 0; i < 100; i++) { dt = Read1<MySqlConnection>(query); // ~9800ms dt = Read2<MySqlConnection, MySqlDataAdapter>(query); // ~2300ms dt = Read1<SQLiteConnection>(query); // ~4000ms dt = Read2<SQLiteConnection, SQLiteDataAdapter>(query); // ~2000ms dt = Read1<SqlCeConnection>(query); // ~5700ms dt = Read2<SqlCeConnection, SqlCeDataAdapter>(query); // ~5700ms dt = Read1<SqlConnection>(query); // ~850ms dt = Read2<SqlConnection, SqlDataAdapter>(query); // ~600ms dt = Read1<VistaDBConnection>(query); // ~3900ms dt = Read2<VistaDBConnection, VistaDBDataAdapter>(query); // ~3700ms } sw.Stop(); MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString());

Read1 ve mejor en los ojos, pero el adaptador de datos funciona mejor (para no confundir ese db superado al otro, las consultas fueron todas diferentes). La diferencia entre los dos dependía de la consulta sin embargo. La razón podría ser que Load requiere varias restricciones verificadas fila por fila desde la documentación al agregar filas (es un método en DataTable ) mientras Fill está en DataAdapters que fueron diseñados solo para eso: creación rápida de DataTables.